react_on_rails 15.0.0.alpha.1 → 15.0.0.rc.0

data/lib/react_on_rails/helper.rb

@@ -32,7 +32,7 @@ module ReactOnRails
     #
     #   Exposing the react_component_name is necessary to both a plain ReactComponent as well as
     #     a generator:
-    #   See README.md for how to "register" your react components.
+    #   See README.md for how to "register" your React components.
     #   See spec/dummy/client/app/packs/server-bundle.js and
     #     spec/dummy/client/app/packs/client-bundle.js for examples of this.
     #
@@ -119,34 +119,74 @@ module ReactOnRails
     # @option options [Hash] :props Props to pass to the react component
     # @option options [String] :dom_id DOM ID of the component container
     # @option options [Hash] :html_options Options passed to content_tag
-    # @option options [Boolean] :prerender Set to false to disable server-side rendering
     # @option options [Boolean] :trace Set to true to add extra debugging information to the HTML
     # @option options [Boolean] :raise_on_prerender_error Set to true to raise exceptions during server-side rendering
     # Any other options are passed to the content tag, including the id.
     def stream_react_component(component_name, options = {})
-      unless ReactOnRails::Utils.react_on_rails_pro?
-        raise ReactOnRails::Error,
-              "You must use React on Rails Pro to use the stream_react_component method."
-      end
-
-      if @rorp_rendering_fibers.nil?
-        raise ReactOnRails::Error,
-              "You must call stream_view_containing_react_components to render the view containing the react component"
+      # stream_react_component doesn't have the prerender option
+      # Because setting prerender to false is equivalent to calling react_component with prerender: false
+      options[:prerender] = true
+      options = options.merge(force_load: true) unless options.key?(:force_load)
+      run_stream_inside_fiber do
+        internal_stream_react_component(component_name, options)
       end
+    end
 
-      rendering_fiber = Fiber.new do
-        stream = internal_stream_react_component(component_name, options)
-        stream.each_chunk do |chunk|
-          Fiber.yield chunk
-        end
+    # Renders the React Server Component (RSC) payload for a given component. This helper generates
+    # a special format designed by React for serializing server components and transmitting them
+    # to the client.
+    #
+    # @return [String] Returns a Newline Delimited JSON (NDJSON) stream where each line contains a JSON object with:
+    #   - html: The RSC payload containing the rendered server components and client component references
+    #   - consoleReplayScript: JavaScript to replay server-side console logs in the client
+    #   - hasErrors: Boolean indicating if any errors occurred during rendering
+    #   - isShellReady: Boolean indicating if the initial shell is ready for hydration
+    #
+    # Example NDJSON stream:
+    #   {"html":"<RSC Payload>","consoleReplayScript":"","hasErrors":false,"isShellReady":true}
+    #   {"html":"<RSC Payload>","consoleReplayScript":"console.log('Loading...')","hasErrors":false,"isShellReady":true}
+    #
+    # The RSC payload within the html field contains:
+    # - The component's rendered output from the server
+    # - References to client components that need hydration
+    # - Data props passed to client components
+    #
+    # @param component_name [String] The name of the React component to render. This component should
+    #   be a server component or a mixed component tree containing both server and client components.
+    #
+    # @param options [Hash] Options for rendering the component
+    # @option options [Hash] :props Props to pass to the component (default: {})
+    # @option options [Boolean] :trace Enable tracing for debugging (default: false)
+    # @option options [String] :id Custom DOM ID for the component container (optional)
+    #
+    # @example Basic usage with a server component
+    #   <%= rsc_payload_react_component("ReactServerComponentPage") %>
+    #
+    # @example With props and tracing enabled
+    #   <%= rsc_payload_react_component("RSCPostsPage",
+    #         props: { artificialDelay: 1000 },
+    #         trace: true) %>
+    #
+    # @note This helper requires React Server Components support to be enabled in your configuration:
+    #   ReactOnRailsPro.configure do |config|
+    #     config.enable_rsc_support = true
+    #   end
+    #
+    # @raise [ReactOnRailsPro::Error] if RSC support is not enabled in configuration
+    #
+    # @note You don't have to deal directly with this helper function - it's used internally by the
+    # `rsc_payload_route` helper function. The returned data from this function is used internally by
+    # components registered using the `registerServerComponent` function. Don't use it unless you need
+    # more control over the RSC payload generation. To know more about RSC payload, see the following link:
+    # @see https://www.shakacode.com/react-on-rails-pro/docs/how-react-server-components-works.md
+    #   for technical details about the RSC payload format
+    def rsc_payload_react_component(component_name, options = {})
+      # rsc_payload_react_component doesn't have the prerender option
+      # Because setting prerender to false will not do anything
+      options[:prerender] = true
+      run_stream_inside_fiber do
+        internal_rsc_payload_react_component(component_name, options)
       end
-
-      @rorp_rendering_fibers << rendering_fiber
-
-      # return the first chunk of the fiber
-      # It contains the initial html of the component
-      # all updates will be appended to the stream sent to browser
-      rendering_fiber.resume
     end
 
     # react_component_hash is used to return multiple HTML strings for server rendering, such as for
@@ -207,17 +247,19 @@ module ReactOnRails
     # props: Ruby Hash or JSON string which contains the properties to pass to the redux store.
     # Options
     #    defer: false -- pass as true if you wish to render this below your component.
-    def redux_store(store_name, props: {}, defer: false)
+    #    force_load: false -- pass as true if you wish to hydrate this store immediately instead of
+    #                        waiting for the page to load.
+    def redux_store(store_name, props: {}, defer: false, force_load: nil)
+      force_load = ReactOnRails.configuration.force_load if force_load.nil?
       redux_store_data = { store_name: store_name,
-                           props: props }
+                           props: props,
+                           force_load: force_load }
       if defer
-        @registered_stores_defer_render ||= []
-        @registered_stores_defer_render << redux_store_data
+        registered_stores_defer_render << redux_store_data
         "YOU SHOULD NOT SEE THIS ON YOUR VIEW -- Uses as a code block, like <% redux_store %> " \
           "and not <%= redux store %>"
       else
-        @registered_stores ||= []
-        @registered_stores << redux_store_data
+        registered_stores << redux_store_data
         result = render_redux_store_data(redux_store_data)
         prepend_render_rails_context(result)
       end
@@ -229,9 +271,9 @@ module ReactOnRails
     # client side rendering of this hydration data, which is a hidden div with a matching class
     # that contains a data props.
     def redux_store_hydration_data
-      return if @registered_stores_defer_render.blank?
+      return if registered_stores_defer_render.blank?
 
-      @registered_stores_defer_render.reduce(+"") do |accum, redux_store_data|
+      registered_stores_defer_render.reduce(+"") do |accum, redux_store_data|
         accum << render_redux_store_data(redux_store_data)
       end.html_safe
     end
@@ -321,6 +363,7 @@ module ReactOnRails
       # ALERT: Keep in sync with node_package/src/types/index.ts for the properties of RailsContext
       @rails_context ||= begin
         result = {
+          componentRegistryTimeout: ReactOnRails.configuration.component_registry_timeout,
           railsEnv: Rails.env,
           inMailer: in_mailer?,
           # Locale settings
@@ -330,8 +373,14 @@ module ReactOnRails
           # TODO: v13 just use the version if existing
           rorPro: ReactOnRails::Utils.react_on_rails_pro?
         }
+
         if ReactOnRails::Utils.react_on_rails_pro?
           result[:rorProVersion] = ReactOnRails::Utils.react_on_rails_pro_version
+
+          if ReactOnRails::Utils.rsc_support_enabled?
+            rsc_payload_url = ReactOnRailsPro.configuration.rsc_payload_generation_url_path
+            result[:rscPayloadGenerationUrlPath] = rsc_payload_url
+          end
         end
 
         if defined?(request) && request.present?
@@ -379,8 +428,13 @@ module ReactOnRails
         is_component_pack_present = File.exist?(generated_components_pack_path(react_component_name))
         raise_missing_autoloaded_bundle(react_component_name) unless is_component_pack_present
       end
-      append_javascript_pack_tag("generated/#{react_component_name}",
-                                 defer: ReactOnRails.configuration.defer_generated_component_packs)
+
+      options = { defer: ReactOnRails.configuration.generated_component_packs_loading_strategy == :defer }
+      # Old versions of Shakapacker don't support async script tags.
+      # ReactOnRails.configure already validates if async loading is supported by the installed Shakapacker version.
+      # Therefore, we only need to pass the async option if the loading strategy is explicitly set to :async
+      options[:async] = true if ReactOnRails.configuration.generated_component_packs_loading_strategy == :async
+      append_javascript_pack_tag("generated/#{react_component_name}", **options)
       append_stylesheet_pack_tag("generated/#{react_component_name}")
     end
 
@@ -388,8 +442,56 @@ module ReactOnRails
 
     private
 
+    def run_stream_inside_fiber
+      unless ReactOnRails::Utils.react_on_rails_pro?
+        raise ReactOnRails::Error,
+              "You must use React on Rails Pro to use the stream_react_component method."
+      end
+
+      if @rorp_rendering_fibers.nil?
+        raise ReactOnRails::Error,
+              "You must call stream_view_containing_react_components to render the view containing the react component"
+      end
+
+      rendering_fiber = Fiber.new do
+        stream = yield
+        stream.each_chunk do |chunk|
+          Fiber.yield chunk
+        end
+      end
+
+      @rorp_rendering_fibers << rendering_fiber
+
+      # return the first chunk of the fiber
+      # It contains the initial html of the component
+      # all updates will be appended to the stream sent to browser
+      rendering_fiber.resume
+    end
+
+    def registered_stores
+      @registered_stores ||= []
+    end
+
+    def registered_stores_defer_render
+      @registered_stores_defer_render ||= []
+    end
+
+    def registered_stores_including_deferred
+      registered_stores + registered_stores_defer_render
+    end
+
+    def create_render_options(react_component_name, options)
+      # If no store dependencies are passed, default to all registered stores up till now
+      unless options.key?(:store_dependencies)
+        store_dependencies = registered_stores_including_deferred.map { |store| store[:store_name] }
+        options = options.merge(store_dependencies: store_dependencies.presence)
+      end
+      ReactOnRails::ReactComponent::RenderOptions.new(react_component_name: react_component_name,
+                                                      options: options)
+    end
+
     def internal_stream_react_component(component_name, options = {})
-      options = options.merge(stream?: true)
+      options = options.merge(render_mode: :html_streaming)
       result = internal_react_component(component_name, options)
       build_react_component_result_for_server_streamed_content(
         rendered_html_stream: result[:result],
@@ -398,6 +500,15 @@ module ReactOnRails
       )
     end
 
+    def internal_rsc_payload_react_component(react_component_name, options = {})
+      options = options.merge(render_mode: :rsc_payload_streaming)
+      render_options = create_render_options(react_component_name, options)
+      json_stream = server_rendered_react_component(render_options)
+      json_stream.transform do |chunk|
+        "#{chunk.to_json}\n".html_safe
+      end
+    end
+
     def generated_components_pack_path(component_name)
       "#{ReactOnRails::PackerUtils.packer_source_entry_path}/generated/#{component_name}.js"
     end
@@ -489,14 +600,13 @@ module ReactOnRails
       )
     end
 
-    def compose_react_component_html_with_spec_and_console(component_specification_tag, rendered_output, console_script)
+    def compose_react_component_html_with_spec_and_console(component_specification_tag, rendered_output,
+                                                           console_script)
       # IMPORTANT: Ensure that we mark string as html_safe to avoid escaping.
-      html_content = <<~HTML
-        #{rendered_output}
-              #{component_specification_tag}
-              #{console_script}
-      HTML
-      html_content.strip.html_safe
+      added_html = "#{component_specification_tag}\n#{console_script}".strip
+      added_html = added_html.present? ? "\n#{added_html}" : ""
+
+      "#{rendered_output}#{added_html}".html_safe
     end
 
     def rails_context_if_not_already_rendered
@@ -514,7 +624,9 @@ module ReactOnRails
 
     # prepend the rails_context if not yet applied
     def prepend_render_rails_context(render_value)
-      "#{rails_context_if_not_already_rendered}\n#{render_value}".strip.html_safe
+      rails_context_content = rails_context_if_not_already_rendered
+      rails_context_content = rails_context_content.present? ? "#{rails_context_content}\n" : ""
+      "#{rails_context_content}#{render_value}".html_safe
     end
 
     def internal_react_component(react_component_name, options = {})
@@ -525,8 +637,7 @@ module ReactOnRails
       # (re-hydrate the data). This enables react rendered on the client to see that the
       # server has already rendered the HTML.
 
-      render_options = ReactOnRails::ReactComponent::RenderOptions.new(react_component_name: react_component_name,
-                                                                       options: options)
+      render_options = create_render_options(react_component_name, options)
 
       # Setup the page_loaded_js, which is the same regardless of prerendering or not!
       # The reason is that React is smart about not doing extra work if the server rendering did its job.
@@ -534,14 +645,18 @@ module ReactOnRails
                                                 json_safe_and_pretty(render_options.client_props).html_safe,
                                                 type: "application/json",
                                                 class: "js-react-on-rails-component",
+                                                id: "js-react-on-rails-component-#{render_options.dom_id}",
                                                 "data-component-name" => render_options.react_component_name,
                                                 "data-trace" => (render_options.trace ? true : nil),
-                                                "data-dom-id" => render_options.dom_id)
+                                                "data-dom-id" => render_options.dom_id,
+                                                "data-store-dependencies" => render_options.store_dependencies&.to_json,
+                                                "data-force-load" => (render_options.force_load ? true : nil),
+                                                "data-render-request-id" => render_options.render_request_id)
 
       if render_options.force_load
         component_specification_tag.concat(
           content_tag(:script, %(
-ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
+typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
           ).html_safe)
         )
       end
@@ -558,12 +673,22 @@ ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
     end
 
     def render_redux_store_data(redux_store_data)
-      result = content_tag(:script,
-                           json_safe_and_pretty(redux_store_data[:props]).html_safe,
-                           type: "application/json",
-                           "data-js-react-on-rails-store" => redux_store_data[:store_name].html_safe)
+      store_hydration_data = content_tag(:script,
+                                         json_safe_and_pretty(redux_store_data[:props]).html_safe,
+                                         type: "application/json",
+                                         "data-js-react-on-rails-store" => redux_store_data[:store_name].html_safe,
+                                         "data-force-load" => (redux_store_data[:force_load] ? true : nil))
+
+      if redux_store_data[:force_load]
+        store_hydration_data.concat(
+          content_tag(:script, <<~JS.strip_heredoc.html_safe
+            typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsStoreLoaded('#{redux_store_data[:store_name]}');
+          JS
+          )
+        )
+      end
 
-      prepend_render_rails_context(result)
+      prepend_render_rails_context(store_hydration_data)
     end
 
     def props_string(props)
@@ -620,7 +745,7 @@ ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
       js_code = ReactOnRails::ServerRenderingJsCode.server_rendering_component_js_code(
         props_string: props_string(props).gsub("\u2028", '\u2028').gsub("\u2029", '\u2029'),
         rails_context: rails_context(server_side: true).to_json,
-        redux_stores: initialize_redux_stores,
+        redux_stores: initialize_redux_stores(render_options),
         react_component_name: react_component_name,
         render_options: render_options
       )
@@ -636,7 +761,7 @@ ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
                                                js_code: js_code)
       end
 
-      if render_options.stream?
+      if render_options.streaming?
         result.transform do |chunk_json_result|
           if should_raise_streaming_prerender_error?(chunk_json_result, render_options)
             raise_prerender_error(chunk_json_result, react_component_name, props, js_code)
@@ -651,17 +776,20 @@ ReactOnRails.reactOnRailsComponentLoaded('#{render_options.dom_id}');
       result
     end
 
-    def initialize_redux_stores
+    def initialize_redux_stores(render_options)
       result = +<<-JS
       ReactOnRails.clearHydratedStores();
       JS
 
-      return result unless @registered_stores.present? || @registered_stores_defer_render.present?
+      store_dependencies = render_options.store_dependencies
+      return result unless store_dependencies.present?
 
       declarations = +"var reduxProps, store, storeGenerator;\n"
-      all_stores = (@registered_stores || []) + (@registered_stores_defer_render || [])
+      store_objects = registered_stores_including_deferred.select do |store|
+        store_dependencies.include?(store[:store_name])
+      end
 
-      result << all_stores.each_with_object(declarations) do |redux_store_data, memo|
+      result << store_objects.each_with_object(declarations) do |redux_store_data, memo|
         store_name = redux_store_data[:store_name]
         props = props_string(redux_store_data[:props])
         memo << <<-JS.strip_heredoc

data/lib/react_on_rails/locales/base.rb

@@ -115,11 +115,17 @@ module ReactOnRails
         translations = {}
         defaults = {}
         locale_files.each do |f|
-          translation = YAML.safe_load(File.open(f))
+          safe_load_options = ReactOnRails.configuration.i18n_yml_safe_load_options || {}
+          translation = YAML.safe_load(File.open(f), **safe_load_options)
           key = translation.keys[0]
           val = flatten(translation[key])
           translations = translations.deep_merge(key => val)
           defaults = defaults.deep_merge(flatten_defaults(val)) if key == default_locale
+        rescue Psych::Exception => e
+          raise ReactOnRails::Error, <<~MSG
+            Error parsing #{f}: #{e.message}
+            Consider fixing unsafe YAML or permitting with config.i18n_yml_safe_load_options
+          MSG
         end
         [translations.to_json, defaults.to_json]
       end

data/lib/react_on_rails/packer_utils.rb

@@ -45,6 +45,10 @@ module ReactOnRails
       packer.dev_server.running?
     end
 
+    def self.dev_server_url
+      "#{packer.dev_server.protocol}://#{packer.dev_server.host_with_port}"
+    end
+
     def self.shakapacker_version
       return @shakapacker_version if defined?(@shakapacker_version)
       return nil unless ReactOnRails::Utils.gem_available?("shakapacker")
@@ -74,16 +78,32 @@ module ReactOnRails
       # the webpack-dev-server is provided by the config value
       # "same_bundle_for_client_and_server" where a value of true
       # would mean that the bundle is created by the webpack-dev-server
-      is_server_bundle = bundle_name == ReactOnRails.configuration.server_bundle_js_file
+      is_bundle_running_on_server = (bundle_name == ReactOnRails.configuration.server_bundle_js_file) ||
+                                    (bundle_name == ReactOnRails.configuration.rsc_bundle_js_file)
 
-      if packer.dev_server.running? && (!is_server_bundle ||
+      if packer.dev_server.running? && (!is_bundle_running_on_server ||
         ReactOnRails.configuration.same_bundle_for_client_and_server)
-        "#{packer.dev_server.protocol}://#{packer.dev_server.host_with_port}#{hashed_bundle_name}"
+        "#{dev_server_url}#{hashed_bundle_name}"
       else
         File.expand_path(File.join("public", hashed_bundle_name)).to_s
       end
     end
 
+    def self.public_output_uri_path
+      "#{packer.config.public_output_path.relative_path_from(packer.config.public_path)}/"
+    end
+
+    # The function doesn't ensure that the asset exists.
+    # - It just returns url to the asset if dev server is running
+    # - Otherwise it returns file path to the asset
+    def self.asset_uri_from_packer(asset_name)
+      if dev_server_running?
+        "#{dev_server_url}/#{public_output_uri_path}#{asset_name}"
+      else
+        File.join(packer_public_output_path, asset_name).to_s
+      end
+    end
+
     def self.precompile?
       return ::Webpacker.config.webpacker_precompile? if using_webpacker_const?
       return ::Shakapacker.config.shakapacker_precompile? if using_shakapacker_const?

data/lib/react_on_rails/packs_generator.rb

@@ -44,11 +44,66 @@ module ReactOnRails
       puts(Rainbow("Generated Packs: #{output_path}").yellow)
     end
 
+    def first_js_statement_in_code(content) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      return "" if content.nil? || content.empty?
+
+      start_index = 0
+      content_length = content.length
+
+      while start_index < content_length
+        # Skip whitespace
+        start_index += 1 while start_index < content_length && content[start_index].match?(/\s/)
+
+        break if start_index >= content_length
+
+        current_chars = content[start_index, 2]
+
+        case current_chars
+        when "//"
+          # Single-line comment
+          newline_index = content.index("\n", start_index)
+          return "" if newline_index.nil?
+
+          start_index = newline_index + 1
+        when "/*"
+          # Multi-line comment
+          comment_end = content.index("*/", start_index)
+          return "" if comment_end.nil?
+
+          start_index = comment_end + 2
+        else
+          # Found actual content
+          next_line_index = content.index("\n", start_index)
+          return next_line_index ? content[start_index...next_line_index].strip : content[start_index..].strip
+        end
+      end
+
+      ""
+    end
+
+    def client_entrypoint?(file_path)
+      content = File.read(file_path)
+      # has "use client" directive. It can be "use client" or 'use client'
+      first_js_statement_in_code(content).match?(/^["']use client["'](?:;|\s|$)/)
+    end
+
     def pack_file_contents(file_path)
       registered_component_name = component_name(file_path)
-      <<~FILE_CONTENT
-        import ReactOnRails from 'react-on-rails';
-        import #{registered_component_name} from '#{relative_component_path_from_generated_pack(file_path)}';
+      load_server_components = ReactOnRails::Utils.rsc_support_enabled?
+
+      if load_server_components && !client_entrypoint?(file_path)
+        return <<~FILE_CONTENT.strip
+          import registerServerComponent from 'react-on-rails/registerServerComponent/client';
+
+          registerServerComponent("#{registered_component_name}");
+        FILE_CONTENT
+      end
+
+      relative_component_path = relative_component_path_from_generated_pack(file_path)
+
+      <<~FILE_CONTENT.strip
+        import ReactOnRails from 'react-on-rails/client';
+        import #{registered_component_name} from '#{relative_component_path}';
 
         ReactOnRails.register({#{registered_component_name}});
       FILE_CONTENT
@@ -61,23 +116,41 @@ module ReactOnRails
       puts(Rainbow("Generated Server Bundle: #{generated_server_bundle_file_path}").orange)
     end
 
+    def build_server_pack_content(component_on_server_imports, server_components, client_components)
+      content = <<~FILE_CONTENT
+        import ReactOnRails from 'react-on-rails';
+
+        #{component_on_server_imports.join("\n")}\n
+      FILE_CONTENT
+
+      if server_components.any?
+        content += <<~FILE_CONTENT
+          import registerServerComponent from 'react-on-rails/registerServerComponent/server';
+          registerServerComponent({#{server_components.join(",\n")}});\n
+        FILE_CONTENT
+      end
+
+      content + "ReactOnRails.register({#{client_components.join(",\n")}});"
+    end
+
     def generated_server_pack_file_content
       common_components_for_server_bundle = common_component_to_path.delete_if { |k| server_component_to_path.key?(k) }
       component_for_server_registration_to_path = common_components_for_server_bundle.merge(server_component_to_path)
 
-      server_component_imports = component_for_server_registration_to_path.map do |name, component_path|
+      component_on_server_imports = component_for_server_registration_to_path.map do |name, component_path|
         "import #{name} from '#{relative_path(generated_server_bundle_file_path, component_path)}';"
       end
 
-      components_to_register = component_for_server_registration_to_path.keys
-
-      <<~FILE_CONTENT
-        import ReactOnRails from 'react-on-rails';
+      load_server_components = ReactOnRails::Utils.rsc_support_enabled?
+      server_components = component_for_server_registration_to_path.keys.delete_if do |name|
+        next true unless load_server_components
 
-        #{server_component_imports.join("\n")}
+        component_path = component_for_server_registration_to_path[name]
+        client_entrypoint?(component_path)
+      end
+      client_components = component_for_server_registration_to_path.keys - server_components
 
-        ReactOnRails.register({#{components_to_register.join(",\n")}});
-      FILE_CONTENT
+      build_server_pack_content(component_on_server_imports, server_components, client_components)
     end
 
     def add_generated_pack_to_server_bundle

data/lib/react_on_rails/prerender_error.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rainbow"
+
 # rubocop:disable: Layout/IndentHeredoc
 module ReactOnRails
   class PrerenderError < ::ReactOnRails::Error
@@ -51,11 +53,17 @@ module ReactOnRails
         message << <<~MSG
           Encountered error:
 
-          #{err}
+          #{err.inspect}
 
         MSG
 
-        backtrace = err.backtrace.first(15).join("\n")
+        backtrace = if Utils.full_text_errors_enabled?
+                      err.backtrace.join("\n")
+                    else
+                      "#{Rails.backtrace_cleaner.clean(err.backtrace).join("\n")}\n" +
+                        Rainbow("The rest of the backtrace is hidden. " \
+                                "To see the full backtrace, set FULL_TEXT_ERRORS=true.").red
+                    end
       else
         backtrace = nil
       end

data/lib/react_on_rails/react_component/render_options.rb

@@ -15,9 +15,17 @@ module ReactOnRails
       def initialize(react_component_name: required("react_component_name"), options: required("options"))
         @react_component_name = react_component_name.camelize
         @options = options
+        # The render_request_id serves as a unique identifier for each render request.
+        # We cannot rely solely on dom_id, as it should be unique for each component on the page,
+        # but the server can render the same page multiple times concurrently for different users.
+        # Therefore, we need an additional unique identifier that can be used both on the client and server.
+        # This ID can also be used to associate specific data with a particular rendered component
+        # on either the server or client.
+        # This ID is only present if RSC support is enabled because it's only used in that case.
+        @render_request_id = self.class.generate_request_id if ReactOnRails::Utils.rsc_support_enabled?
       end
 
-      attr_reader :react_component_name
+      attr_reader :react_component_name, :render_request_id
 
       def throw_js_errors
         options.fetch(:throw_js_errors, false)
@@ -111,8 +119,36 @@ module ReactOnRails
         options[key] = value
       end
 
-      def stream?
-        options[:stream?]
+      def render_mode
+        # Determines the React rendering strategy:
+        # - :sync: Synchronous SSR using renderToString (blocking and rendering in one shot)
+        # - :html_streaming: Progressive SSR using renderToPipeableStream (non-blocking and rendering incrementally)
+        # - :rsc_payload_streaming: Server Components serialized in React flight format
+        #   (non-blocking and rendering incrementally).
+        options.fetch(:render_mode, :sync)
+      end
+
+      def streaming?
+        # Returns true if the component should be rendered incrementally
+        %i[html_streaming rsc_payload_streaming].include?(render_mode)
+      end
+
+      def rsc_payload_streaming?
+        # Returns true if the component should be rendered as a React Server Component
+        render_mode == :rsc_payload_streaming
+      end
+
+      def html_streaming?
+        # Returns true if the component should be rendered incrementally
+        render_mode == :html_streaming
+      end
+
+      def store_dependencies
+        options[:store_dependencies]
+      end
+
+      def self.generate_request_id
+        SecureRandom.uuid
       end
 
       private