react_on_rails 17.0.0.rc.0 → 17.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02f0fa1befbed99b17f624249398f47b5a1395ed5407079a472ad39218d2cfc1
-  data.tar.gz: f8b4e5a3abf309b98f7b244d1a807acb29096ff7ae1ea115e780eefd35f2d609
+  metadata.gz: 0feb399078c3e60a35b5e36bc257cc2711bf793fd04dab39c3ccfcfdd8448cd8
+  data.tar.gz: 3848ca13d934d2fda5ca63f8b7660aaac360ac3daec07d7a15433a647d058c44
 SHA512:
-  metadata.gz: c594211d78c05817226dd5d4ff06e7bb4f377b57320cdb824de7a8902ec40d66473b28da64e0f6d2df5b445786a050d1c6b61779af3fea0c1c4793f3955efa63
-  data.tar.gz: e86d35866011de451f725c441539bc7f8400e83d9702a4a3b9058d385e483a926229b4e33e18685636d73700bc7a9a1106246d78174a726327b47b8b0f1645d9
+  metadata.gz: 3d2a9e86976672ce1b5ae6b869a9d777bb652b35423cb7b361614db8ccdb710423ad8434115f460ffd7522336a9eb8eec74382bd793f4cd537dfe2d12b69df46
+  data.tar.gz: b75324ae9ad146861baebd20716ef293c28509734afbf206da63275db4d29c6a24115a9e2b834781d275a1a586fd9215cdd208c1e93a1101a47d275436cbfda1

data/.rubocop.yml

@@ -11,6 +11,7 @@ AllCops:
 
   Exclude:
     - 'spec/dummy/bin/*'
+    - 'spike/**/*'  # Exploratory spike code outside lib/ — not part of the production surface
 
 Naming/FileName:
   Exclude:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    react_on_rails (17.0.0.rc.0)
+    react_on_rails (17.0.0.rc.1)
       addressable
       connection_pool
       execjs (~> 2.5)
@@ -487,4 +487,4 @@ DEPENDENCIES
   webdrivers (= 5.3.0)
 
 BUNDLED WITH
-   2.5.9
+  4.0.10

data/lib/generators/react_on_rails/base_generator.rb

@@ -6,11 +6,13 @@ require "erb"
 require_relative "generator_messages"
 require_relative "generator_helper"
 require_relative "js_dependency_manager"
+require_relative "shakapacker_precompile_hook_helper"
 module ReactOnRails
   module Generators
     class BaseGenerator < Rails::Generators::Base
       include GeneratorHelper
       include JsDependencyManager
+      include ShakapackerPrecompileHookHelper
 
       Rails::Generators.hide_namespace(namespace)
       source_root(File.expand_path("templates", __dir__))
@@ -22,11 +24,22 @@ module ReactOnRails
                    desc: "Install Redux package and Redux version of Hello World Example",
                    aliases: "-R"
 
-      # --rspack
+      # --rspack / --no-rspack (Rspack is the default on fresh installs; --no-rspack selects Webpack)
+      # IMPORTANT: do NOT add a `default:` here. The absence of a default is load-bearing — Thor
+      # only includes :rspack in the options hash when the flag is explicitly passed, which is how
+      # GeneratorHelper#using_rspack? tells an explicit choice from "no flag given" (the latter
+      # falls back to rspack_bundler_default). Adding `default: false` would make
+      # options.key?(:rspack) always true and silently break the fresh-install Rspack default.
+      # (Thor's omit-when-no-default behavior verified against Thor 1.5.0; see Gemfile.lock.)
       class_option :rspack,
                    type: :boolean,
-                   default: false,
-                   desc: "Use Rspack instead of Webpack as the bundler"
+                   desc: "Use Rspack (default) as the bundler; pass --no-rspack to use Webpack"
+
+      # --webpack: friendly alias for --no-rspack (reconciled in GeneratorHelper#explicit_bundler_choice).
+      # No `default:` here either — same load-bearing reason as --rspack above.
+      class_option :webpack,
+                   type: :boolean,
+                   desc: "Use Webpack as the bundler (alias for --no-rspack; --no-webpack is equivalent to --rspack)"
 
       # --pro
       class_option :pro,
@@ -313,6 +326,18 @@ module ReactOnRails
 
       private
 
+      # Fresh-install context: default to Rspack (when Shakapacker supports it) unless the
+      # app already declares a bundler. See GeneratorHelper#fresh_install_rspack_default.
+      # NOTE: InstallGenerator#rspack_bundler_default is an intentional twin of this override
+      # (both generators are independently CLI-invocable); keep the two in sync.
+      def rspack_bundler_default
+        fresh_install_rspack_default
+      end
+
+      def generated_build_test_command
+        shakapacker_build_command(env: "RAILS_ENV=test NODE_ENV=test", environment: "test")
+      end
+
       def generate_new_app_home_page?
         options.new_app? && new_app_root_route_added?
       end

data/lib/generators/react_on_rails/generator_helper.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "shakapacker_precompile_hook_helper"
 
+# rubocop:disable Metrics/ModuleLength
 module GeneratorHelper
+  include ReactOnRails::Generators::ShakapackerPrecompileHookHelper
+
   def package_json
     # Lazy load package_json gem only when actually needed for dependency management
 
@@ -128,11 +132,57 @@ module GeneratorHelper
   def using_rspack?
     return @using_rspack if defined?(@using_rspack)
 
-    # options.key?(:rspack) is true when the generator declares --rspack (e.g. InstallGenerator),
-    # false when it does not (e.g. RscGenerator, ProGenerator). Using .key? rather than .nil?
-    # check on the value makes the intent explicit and avoids relying on Thor returning nil for
-    # undeclared options.
-    @using_rspack = options.key?(:rspack) ? options[:rspack] : rspack_configured_in_project?
+    # An explicit bundler flag always wins. When none was passed (or the generator doesn't
+    # declare the flags, e.g. RscGenerator/ProGenerator), fall back to the bundler default,
+    # which each generator defines for its own context.
+    explicit = explicit_bundler_choice
+    @using_rspack = explicit.nil? ? rspack_bundler_default : explicit
+  end
+
+  # Resolve the explicit bundler flags into a single choice.
+  #
+  # --rspack selects Rspack; --no-rspack and --webpack select Webpack (--webpack is a friendly
+  # alias for --no-rspack, and the auto-generated --no-webpack mirrors --rspack). Returns true
+  # for Rspack, false for Webpack, or nil when no bundler flag was passed (so the caller falls
+  # back to rspack_bundler_default).
+  #
+  # IMPORTANT: this relies on Thor NOT including a nil-defaulted option in the hash when the flag
+  # is absent — options.key?(:rspack)/(:webpack) is true only when the user passed that flag.
+  # Re-adding `default:` to either class_option would make the key always present and break both
+  # the "no flag given" fallback and the conflict detection here.
+  # (Thor's omit-when-no-default behavior verified against Thor 1.5.0; see Gemfile.lock.)
+  #
+  # Passing contradictory flags (e.g. --rspack --webpack) raises a Thor::Error.
+  def explicit_bundler_choice
+    choices = []
+    choices << options[:rspack] if options.key?(:rspack)
+    # --webpack means "use Webpack" (rspack = false); --no-webpack means "use Rspack".
+    # Name the inverted webpack flag so the rspack-boolean intent reads directly.
+    rspack_via_webpack_flag = !options[:webpack]
+    choices << rspack_via_webpack_flag if options.key?(:webpack)
+    return nil if choices.empty?
+
+    if choices.uniq.length > 1
+      raise Thor::Error,
+            "Conflicting bundler flags: pass either Rspack (--rspack) or Webpack " \
+            "(--webpack / --no-rspack), not both."
+    end
+
+    choices.first
+  end
+
+  # True when the user passed any explicit bundler flag
+  # (--rspack/--no-rspack/--webpack/--no-webpack).
+  def bundler_flag_given?
+    options.key?(:rspack) || options.key?(:webpack)
+  end
+
+  # Bundler to use when no explicit bundler flag was passed.
+  # Default (standalone generators like RscGenerator/ProGenerator): respect the existing
+  # project's shakapacker.yml and never impose a bundler. InstallGenerator/BaseGenerator
+  # override this to default fresh installs to Rspack.
+  def rspack_bundler_default
+    rspack_configured_in_project?
   end
 
   # Remap a config path from config/webpack/ to config/rspack/ when using rspack.
@@ -291,25 +341,6 @@ module GeneratorHelper
     shakapacker_version_9_3_or_higher?
   end
 
-  def parse_shakapacker_yml(path)
-    require "yaml"
-    # Use safe_load_file for security (defense-in-depth, even though this is user's own config)
-    # permitted_classes: [Symbol] allows symbol keys which shakapacker.yml may use
-    # aliases: true allows YAML anchors (&default, *default) commonly used in Rails configs
-    YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
-  rescue ArgumentError
-    # Older Psych versions don't support all parameters - try without aliases
-    begin
-      YAML.safe_load_file(path, permitted_classes: [Symbol])
-    rescue ArgumentError
-      # Very old Psych - fall back to safe_load with File.read
-      YAML.safe_load(File.read(path), permitted_classes: [Symbol]) # rubocop:disable Style/YAMLFileRead
-    end
-  rescue StandardError
-    # If we can't parse the file, return empty config
-    {}
-  end
-
   # Check if Shakapacker 9.3.0 or higher is available
   # This version made SWC the default JavaScript transpiler
   def shakapacker_version_9_3_or_higher?
@@ -330,10 +361,34 @@ module GeneratorHelper
   # `assets_bundler` inside the `default: &default` block, and our generator writes
   # it there too via configure_rspack_in_shakapacker.
   def rspack_configured_in_project?
+    shakapacker_assets_bundler_value == "rspack"
+  end
+
+  # Fresh-install bundler default used by InstallGenerator/BaseGenerator: prefer Rspack
+  # when Shakapacker supports it (Rspack landed in Shakapacker 9.0), but never override an
+  # existing app's explicit assets_bundler choice. On a brand-new install where Shakapacker
+  # isn't loaded yet, shakapacker_version_9_or_higher? optimistically returns true.
+  def fresh_install_rspack_default
+    return rspack_configured_in_project? if project_declares_assets_bundler?
+
+    shakapacker_version_9_or_higher?
+  end
+
+  # True when config/shakapacker.yml exists and its default: section declares an
+  # assets_bundler (i.e., the project has already made an explicit bundler choice).
+  def project_declares_assets_bundler?
+    !shakapacker_assets_bundler_value.nil?
+  end
+
+  # Single source for the config/shakapacker.yml default-section read shared by
+  # rspack_configured_in_project? and project_declares_assets_bundler?. Returns the
+  # assets_bundler value (e.g. "rspack"), or nil when the file is absent or the key is unset.
+  # Only the default: section is inspected (see rspack_configured_in_project? for the rationale).
+  def shakapacker_assets_bundler_value
     shakapacker_yml_path = File.join(destination_root, "config/shakapacker.yml")
-    return false unless File.exist?(shakapacker_yml_path)
+    return nil unless File.exist?(shakapacker_yml_path)
 
-    config = parse_shakapacker_yml(shakapacker_yml_path)
-    config.dig("default", "assets_bundler") == "rspack"
+    parse_shakapacker_yml(shakapacker_yml_path).dig("default", "assets_bundler")
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/generators/react_on_rails/generator_messages/ci_section.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 require "rainbow"
+require_relative "../shakapacker_precompile_hook_helper"
 
 module GeneratorMessages
   module CiSection
+    include ReactOnRails::Generators::ShakapackerPrecompileHookHelper
+
     private
 
     def build_ci_section(app_root: Dir.pwd, ci_workflow_generated: false)
@@ -25,6 +28,11 @@ module GeneratorMessages
                         else
                           ""
                         end
+      manual_build_command = shakapacker_build_command(
+        env: "RAILS_ENV=test NODE_ENV=test",
+        app_root: app_root,
+        environment: "test"
+      )
 
       <<~CI
 
@@ -35,7 +43,7 @@ module GeneratorMessages
         #{ci_status}
 
         To build bundles manually before tests:
-        #{Rainbow('RAILS_ENV=test NODE_ENV=test bin/shakapacker').cyan}#{build_test_hint}
+        #{Rainbow(manual_build_command).cyan}#{build_test_hint}
       CI
     end
   end

data/lib/generators/react_on_rails/install_generator.rb

@@ -9,6 +9,7 @@ require_relative "generator_messages"
 require_relative "js_dependency_manager"
 require_relative "pro_setup"
 require_relative "rsc_setup"
+require_relative "shakapacker_precompile_hook_helper"
 # Load-path require: git_utils lives under react_on_rails/lib, not relative to this generator directory.
 require "react_on_rails/git_utils"
 
@@ -23,6 +24,7 @@ module ReactOnRails
       include JsDependencyManager
       include ProSetup
       include RscSetup
+      include ShakapackerPrecompileHookHelper
 
       # fetch USAGE file for details generator description
       source_root(File.expand_path(__dir__))
@@ -41,11 +43,22 @@ module ReactOnRails
                    desc: "Generate TypeScript files and install TypeScript dependencies. Default: false",
                    aliases: "-T"
 
-      # --rspack
+      # --rspack / --no-rspack (Rspack is the default on fresh installs; --no-rspack selects Webpack)
+      # IMPORTANT: do NOT add a `default:` here. The absence of a default is load-bearing — Thor
+      # only includes :rspack in the options hash when the flag is explicitly passed, which is how
+      # GeneratorHelper#using_rspack? tells an explicit choice from "no flag given" (the latter
+      # falls back to rspack_bundler_default). Adding `default: false` would make
+      # options.key?(:rspack) always true and silently break the fresh-install Rspack default.
+      # (Thor's omit-when-no-default behavior verified against Thor 1.5.0; see Gemfile.lock.)
       class_option :rspack,
                    type: :boolean,
-                   default: false,
-                   desc: "Use Rspack instead of Webpack as the bundler. Default: false"
+                   desc: "Use Rspack (default) as the bundler; pass --no-rspack to use Webpack"
+
+      # --webpack: friendly alias for --no-rspack (reconciled in GeneratorHelper#explicit_bundler_choice).
+      # No `default:` here either — same load-bearing reason as --rspack above.
+      class_option :webpack,
+                   type: :boolean,
+                   desc: "Use Webpack as the bundler (alias for --no-rspack; --no-webpack is equivalent to --rspack)"
 
       # --ignore-warnings
       class_option :ignore_warnings,
@@ -87,7 +100,6 @@ module ReactOnRails
 
       # Removed: --skip-shakapacker-install (Shakapacker is now a required dependency)
 
-      SHAKAPACKER_YML_PATH = "config/shakapacker.yml"
       HELLO_WORLD_ROUTE = "hello_world"
       HELLO_SERVER_ROUTE = "hello_server"
       # Matches the stock `bin/dev` written by Rails 8.x. Rails 7.1 commonly
@@ -196,6 +208,14 @@ module ReactOnRails
 
       private
 
+      # Fresh-install context: default to Rspack (when Shakapacker supports it) unless the
+      # app already declares a bundler. See GeneratorHelper#fresh_install_rspack_default.
+      # NOTE: BaseGenerator#rspack_bundler_default is an intentional twin of this override
+      # (both generators are independently CLI-invocable); keep the two in sync.
+      def rspack_bundler_default
+        fresh_install_rspack_default
+      end
+
       def invoke_generators
         ensure_shakapacker_installed
         if options.typescript?
@@ -206,7 +226,7 @@ module ReactOnRails
         # `invoke` instantiates child generators with a fresh options hash, so
         # --pretend/--force/--skip must be forwarded explicitly at each boundary.
         invoke "react_on_rails:base", [],
-               { typescript: options.typescript?, redux: options.redux?, rspack: options.rspack?,
+               { typescript: options.typescript?, redux: options.redux?, rspack: using_rspack?,
                  pro: use_pro?, rsc: use_rsc?, new_app: options.new_app?,
                  shakapacker_just_installed: shakapacker_just_installed?,
                  force: options[:force], skip: options[:skip], pretend: options[:pretend] }
@@ -296,18 +316,19 @@ module ReactOnRails
                  { package_manager: package_manager, has_lockfile: has_lockfile,
                    pnpm_version_declared: pnpm_version_declared,
                    pnpm_fallback_version: CI_PNPM_FALLBACK_VERSION,
-                   has_active_record: has_active_record, has_rspec: has_rspec })
+                   has_active_record: has_active_record, has_rspec: has_rspec,
+                   precompile_hook_command: shakapacker_precompile_hook_command(environment: "test") })
         @ci_workflow_generated = true
       end
 
-      # NODE_ENV=production ensures Shakapacker emits a minified production bundle;
-      # without it the default is "development" which produces an unminified dev bundle
-      # and is almost never what `npm run build` is expected to do.
-      DEFAULT_PACKAGE_JSON_SCRIPTS = {
-        "build" => "NODE_ENV=production bin/shakapacker",
-        "build:test" => "RAILS_ENV=test NODE_ENV=test bin/shakapacker"
-      }.freeze
-      private_constant :DEFAULT_PACKAGE_JSON_SCRIPTS
+      # RAILS_ENV=production runs the hook with production Rails config, while
+      # NODE_ENV=production makes Shakapacker emit a minified production bundle.
+      def default_package_json_scripts
+        {
+          "build" => shakapacker_build_command(env: "RAILS_ENV=production NODE_ENV=production"),
+          "build:test" => shakapacker_build_command(env: "RAILS_ENV=test NODE_ENV=test", environment: "test")
+        }
+      end
 
       def add_package_json_scripts
         return if options[:pretend]
@@ -317,7 +338,7 @@ module ReactOnRails
 
         original_text = File.read(package_json_path)
         existing_scripts = JSON.parse(original_text)["scripts"] || {}
-        scripts_to_add = DEFAULT_PACKAGE_JSON_SCRIPTS.reject { |key, _| existing_scripts.key?(key) }
+        scripts_to_add = default_package_json_scripts.reject { |key, _| existing_scripts.key?(key) }
 
         if scripts_to_add.empty?
           say_status :skip, "build scripts already present in package.json", :yellow
@@ -690,7 +711,10 @@ module ReactOnRails
         flags = []
         flags << "--redux" if options.redux?
         flags << "--typescript" if options.typescript?
-        flags << "--rspack" if options.rspack?
+        # Echo the resolved bundler choice (normalized to --rspack/--no-rspack, so a --webpack
+        # alias re-runs as --no-rspack) only when the user passed one explicitly. An unset choice
+        # re-resolves to the fresh-install default on re-run, so we don't pin it here.
+        flags << (using_rspack? ? "--rspack" : "--no-rspack") if bundler_flag_given?
 
         if options.rsc?
           flags << "--rsc"
@@ -838,11 +862,14 @@ module ReactOnRails
 
         seed_package_manager_in_package_json_from_lockfile!
 
-        # Then run the shakapacker installer
-        # Use options.rspack? directly (not using_rspack?): shakapacker.yml doesn't exist yet at this
-        # point, so using_rspack? would fall back to rspack_configured_in_project? which returns false,
-        # causing Shakapacker to install webpack configs into config/webpack/ instead of rspack.
-        shakapacker_install_env = options.rspack? ? { "SHAKAPACKER_ASSETS_BUNDLER" => "rspack" } : {}
+        # Then run the shakapacker installer.
+        # Resolve the bundler via using_rspack?. shakapacker.yml doesn't exist yet at this point,
+        # so the fresh-install default applies: an unset --rspack flag resolves to Rspack when
+        # Shakapacker supports it (shakapacker_version_9_or_higher? is optimistically true on a
+        # brand-new install where Shakapacker isn't loaded yet). An explicit --no-rspack still
+        # selects Webpack. using_rspack? memoizes, so the rest of the run (e.g.
+        # configure_rspack_in_shakapacker) stays consistent with this decision.
+        shakapacker_install_env = using_rspack? ? { "SHAKAPACKER_ASSETS_BUNDLER" => "rspack" } : {}
         success = Bundler.with_unbundled_env do
           system(shakapacker_install_env, "bundle exec rails shakapacker:install")
         end

data/lib/generators/react_on_rails/rsc_setup/client_references.rb

@@ -6,6 +6,8 @@ module ReactOnRails
       module ClientReferences # rubocop:disable Metrics/ModuleLength
         JS_STRING_DELIMITERS = ["'", '"', "`"].freeze
         JS_COMMENT_STATES = %i[line_comment block_comment].freeze
+        # Characters that complete `//` or `/*` after a leading `/`.
+        JS_COMMENT_SECOND_CHARS = ["/", "*"].freeze
         # Known limitation: this list only covers single-character regex preceders. Multi-character
         # JavaScript keywords that legally precede a regex literal (`return`, `typeof`, `void`,
         # `delete`, `throw`, `case`, `in`, `instanceof`) are not represented. A regex like `/\{/`
@@ -243,9 +245,9 @@ module ReactOnRails
           # No parseable `isServer: <bool>` section means this file's plugin call sits outside
           # what the generator's scanner can match (e.g. options are computed at runtime, or the
           # plugin is invoked without an options object). Verification callers intentionally
-          # under-report here: warning about "missing scoped clientReferences" when there's no
-          # section to inspect would only surface noise for dynamic invocations like
-          # `RSCWebpackPlugin(buildOptions())`, where the user has nothing actionable to do.
+          # keep these out of the missing-pattern list because there is no literal section to
+          # classify as broken. They warn separately for dynamic invocations so users can verify
+          # those configs manually.
           return true if sections.empty?
 
           sections.all? do |section|
@@ -258,6 +260,30 @@ module ReactOnRails
           end
         end
 
+        # Counts active `new RSCWebpackPlugin(...)` calls whose first argument is present but
+        # not an object literal. This includes computed options plus static string/template
+        # literals; all are outside the verifier's parseable `{...}` contract.
+        def non_object_literal_rsc_plugin_invocation_count(content)
+          count = 0
+          search_from = 0
+
+          while (match = content.match(RSC_PLUGIN_INVOCATION_REGEX, search_from))
+            call_start = match.begin(0)
+            after_open_paren = match.end(0)
+            unless js_code_position?(content, call_start)
+              search_from = after_open_paren
+              next
+            end
+
+            options_start = first_js_token_index(content, after_open_paren)
+            options_start_char = options_start ? content[options_start] : nil
+            count += 1 if options_start_char && options_start_char != "{" && options_start_char != ")"
+            search_from = after_open_paren
+          end
+
+          count
+        end
+
         def rsc_plugin_defines_client_references?(content, is_server:)
           rsc_plugin_option_sections(content, is_server: is_server).any? do |section|
             rsc_plugin_body_has_top_level_key?(section.fetch(:body), "clientReferences")
@@ -411,28 +437,66 @@ module ReactOnRails
           false
         end
 
+        # Skips whitespace and JS line/block comments, preserving strings as the next token.
+        # Non-object-literal option verification uses this so `new RSCWebpackPlugin("opts")`
+        # warns instead of having the string skipped as incidental syntax.
+        def first_js_token_index(content, start_index)
+          index = start_index
+          state = nil
+          escaped = false
+
+          while index < content.length
+            char = content[index]
+            next_char = content[index + 1]
+
+            if state
+              state, escaped, index = advance_js_scan_state(state, escaped, char, next_char, index)
+              index += 1
+              next
+            end
+
+            return index unless char.match?(/\s/) || (char == "/" && JS_COMMENT_SECOND_CHARS.include?(next_char))
+
+            state, escaped, index = advance_js_scan_state(state, escaped, char, next_char, index)
+
+            index += 1
+          end
+
+          nil
+        end
+
         # Skips whitespace, JS line/block comments, and leading string literals so callers see the
         # next structural character. Without comment skipping, configurations like
         # `new RSCWebpackPlugin( /* opts */ {` would land on `/` and be rejected as "no plugin
         # options" even though the options object is present.
         def first_significant_js_index(content, start_index)
-          index = start_index
+          index = first_js_token_index(content, start_index)
+
+          while index && JS_STRING_DELIMITERS.include?(content[index])
+            string_end = js_string_end_index(content, index)
+            return nil unless string_end
+
+            index = first_js_token_index(content, string_end + 1)
+          end
+
+          index
+        end
+
+        # Scans from a string-opening delimiter at `string_start_index` and returns the index
+        # of the matching closing delimiter, not one past it. Returns nil for unterminated
+        # strings. Callers must ensure `content[string_start_index]` is in JS_STRING_DELIMITERS.
+        def js_string_end_index(content, string_start_index)
           state = nil
           escaped = false
+          index = string_start_index
 
           while index < content.length
             char = content[index]
             next_char = content[index + 1]
-            prev_state = state
+            previous_state = state
             state, escaped, index = advance_js_scan_state(state, escaped, char, next_char, index)
-            # Exiting a block comment leaves `char` as `*` and `index` pointing at the closing
-            # `/`; advance past it so the next iteration evaluates the first character after `*/`.
-            if state || prev_state == :block_comment
-              index += 1
-              next
-            end
 
-            return index unless char.match?(/\s/) || JS_STRING_DELIMITERS.include?(prev_state)
+            return index if previous_state && state.nil?
 
             index += 1
           end

data/lib/generators/react_on_rails/rsc_setup.rb

@@ -538,6 +538,7 @@ module ReactOnRails
         content = File.read(path)
         missing = []
         if content.include?("RSCWebpackPlugin")
+          warn_non_object_literal_rsc_plugin_options_for_config(content)
           unless rsc_plugin_client_references_configured?(content, is_server: true)
             missing << "generated scoped clientReferences in serverWebpackConfig.js"
           end
@@ -555,6 +556,7 @@ module ReactOnRails
         content = File.read(path)
         missing = []
         if content.include?("RSCWebpackPlugin")
+          warn_non_object_literal_rsc_plugin_options_for_config(content)
           unless rsc_plugin_client_references_configured?(content, is_server: false)
             missing << "generated scoped clientReferences in clientWebpackConfig.js"
           end
@@ -571,6 +573,23 @@ module ReactOnRails
         content = File.read(File.join(destination_root, scob_path))
         content.include?("rscWebpackConfig") ? [] : ["rscWebpackConfig in ServerClientOrBoth.js"]
       end
+
+      def warn_non_object_literal_rsc_plugin_options_for_config(content)
+        return unless non_object_literal_rsc_plugin_invocation_count(content).positive?
+
+        warn_non_object_literal_rsc_plugin_options_once
+      end
+
+      def warn_non_object_literal_rsc_plugin_options_once
+        return if @non_object_literal_rsc_plugin_options_warned
+
+        @non_object_literal_rsc_plugin_options_warned = true
+        GeneratorMessages.add_warning(
+          "RSCWebpackPlugin calls use non-object-literal options in one or more webpack configs, " \
+          "so the generator cannot verify whether scoped clientReferences are configured. " \
+          "Please verify your webpack configs manually."
+        )
+      end
     end
   end
 end