react_on_rails 14.2.1 → 16.1.1

data/lib/react_on_rails/packer_utils.rb

@@ -1,127 +1,121 @@
 # frozen_string_literal: true
 
+require "shakapacker"
+
 module ReactOnRails
   module PackerUtils
-    def self.using_packer?
-      using_shakapacker_const? || using_webpacker_const?
+    def self.dev_server_running?
+      Shakapacker.dev_server.running?
     end
 
-    def self.using_shakapacker_const?
-      return @using_shakapacker_const if defined?(@using_shakapacker_const)
-
-      @using_shakapacker_const = ReactOnRails::Utils.gem_available?("shakapacker") &&
-                                 shakapacker_version_requirement_met?([7, 0, 0])
+    def self.dev_server_url
+      "#{Shakapacker.dev_server.protocol}://#{Shakapacker.dev_server.host_with_port}"
     end
 
-    def self.using_webpacker_const?
-      return @using_webpacker_const if defined?(@using_webpacker_const)
+    def self.shakapacker_version
+      return @shakapacker_version if defined?(@shakapacker_version)
 
-      @using_webpacker_const = (ReactOnRails::Utils.gem_available?("shakapacker") &&
-                          shakapacker_version_as_array[0] <= 6) ||
-                               ReactOnRails::Utils.gem_available?("webpacker")
+      @shakapacker_version = Gem.loaded_specs["shakapacker"].version.to_s
     end
 
-    def self.packer_type
-      return "shakapacker" if using_shakapacker_const?
-      return "webpacker" if using_webpacker_const?
-
-      nil
-    end
+    def self.shakapacker_version_as_array
+      return @shakapacker_version_as_array if defined?(@shakapacker_version_as_array)
 
-    def self.packer
-      return nil unless using_packer?
+      match = shakapacker_version.match(ReactOnRails::VersionChecker::VERSION_PARTS_REGEX)
 
-      if using_shakapacker_const?
-        require "shakapacker"
-        return ::Shakapacker
-      end
-      require "webpacker"
-      ::Webpacker
+      # match[4] is the pre-release version, not normally a number but something like "beta.1" or `nil`
+      @shakapacker_version_as_array = [match[1].to_i, match[2].to_i, match[3].to_i, match[4]].compact
     end
 
-    def self.dev_server_running?
-      return false unless using_packer?
-
-      packer.dev_server.running?
+    def self.shakapacker_version_requirement_met?(required_version)
+      @version_checks ||= {}
+      @version_checks[required_version] ||= Gem::Version.new(shakapacker_version) >= Gem::Version.new(required_version)
     end
 
-    def self.shakapacker_version
-      return @shakapacker_version if defined?(@shakapacker_version)
-      return nil unless ReactOnRails::Utils.gem_available?("shakapacker")
-
-      @shakapacker_version = Gem.loaded_specs["shakapacker"].version.to_s
+    def self.supports_async_loading?
+      shakapacker_version_requirement_met?("8.2.0")
     end
 
-    def self.shakapacker_version_as_array
-      match = shakapacker_version.match(ReactOnRails::VersionChecker::MAJOR_MINOR_PATCH_VERSION_REGEX)
-
-      @shakapacker_version_as_array = [match[1].to_i, match[2].to_i, match[3].to_i]
+    def self.supports_basic_pack_generation?
+      shakapacker_version_requirement_met?(ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION)
     end
 
-    def self.shakapacker_version_requirement_met?(required_version)
-      req_ver = semver_to_string(required_version)
-
-      Gem::Version.new(shakapacker_version) >= Gem::Version.new(req_ver)
+    def self.supports_autobundling?
+      min_version = ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION_FOR_AUTO_BUNDLING
+      ::Shakapacker.config.respond_to?(:nested_entries?) && shakapacker_version_requirement_met?(min_version)
     end
 
     # This returns either a URL for the webpack-dev-server, non-server bundle or
     # the hashed server bundle if using the same bundle for the client.
     # Otherwise returns a file path.
     def self.bundle_js_uri_from_packer(bundle_name)
-      hashed_bundle_name = packer.manifest.lookup!(bundle_name)
+      hashed_bundle_name = ::Shakapacker.manifest.lookup!(bundle_name)
 
       # Support for hashing the server-bundle and having that built
       # 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 ::Shakapacker.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.precompile?
-      return ::Webpacker.config.webpacker_precompile? if using_webpacker_const?
-      return ::Shakapacker.config.shakapacker_precompile? if using_shakapacker_const?
+    def self.public_output_uri_path
+      "#{::Shakapacker.config.public_output_path.relative_path_from(::Shakapacker.config.public_path)}/"
+    end
 
-      false
+    # 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?
+      ::Shakapacker.config.shakapacker_precompile?
     end
 
     def self.packer_source_path
-      packer.config.source_path
+      ::Shakapacker.config.source_path
     end
 
     def self.packer_source_entry_path
-      packer.config.source_entry_path
+      ::Shakapacker.config.source_entry_path
     end
 
     def self.nested_entries?
-      packer.config.nested_entries?
+      ::Shakapacker.config.nested_entries?
     end
 
     def self.packer_public_output_path
-      packer.config.public_output_path.to_s
+      ::Shakapacker.config.public_output_path.to_s
     end
 
     def self.manifest_exists?
-      packer.config.public_manifest_path.exist?
+      ::Shakapacker.config.public_manifest_path.exist?
     end
 
     def self.packer_source_path_explicit?
-      packer.config.send(:data)[:source_path].present?
+      ::Shakapacker.config.send(:data)[:source_path].present?
     end
 
     def self.check_manifest_not_cached
-      return unless using_packer? && packer.config.cache_manifest?
+      return unless ::Shakapacker.config.cache_manifest?
 
       msg = <<-MSG.strip_heredoc
           ERROR: you have enabled cache_manifest in the #{Rails.env} env when using the
           ReactOnRails::TestHelper.configure_rspec_to_compile_assets helper
-          To fix this: edit your config/#{packer_type}.yml file and set cache_manifest to false for test.
+          To fix this: edit your config/shakapacker.yml file and set cache_manifest to false for test.
       MSG
       puts wrap_message(msg)
       exit!
@@ -142,7 +136,7 @@ module ReactOnRails
     def self.raise_nested_entries_disabled
       msg = <<~MSG
         **ERROR** ReactOnRails: `nested_entries` is configured to be disabled in shakapacker. Please update \
-        config/#{packer_type}.yml to enable nested entries. for more information read
+        config/shakapacker.yml to enable nested entries. for more information read
         https://www.shakacode.com/react-on-rails/docs/guides/file-system-based-automated-bundle-generation.md#enable-nested_entries-for-shakapacker
       MSG
 
@@ -151,26 +145,22 @@ module ReactOnRails
 
     def self.raise_shakapacker_version_incompatible_for_autobundling
       msg = <<~MSG
-        **ERROR** ReactOnRails: Please upgrade Shakapacker to version #{semver_to_string(ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION)} or \
-        above to use the automated bundle generation feature. The currently installed version is \
-        #{semver_to_string(ReactOnRails::PackerUtils.shakapacker_version_as_array)}.
+        **ERROR** ReactOnRails: Please upgrade ::Shakapacker to version #{ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION_FOR_AUTO_BUNDLING} or \
+        above to use the automated bundle generation feature (which requires nested_entries support). \
+        The currently installed version is #{ReactOnRails::PackerUtils.shakapacker_version}. \
+        Basic pack generation requires ::Shakapacker #{ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION} or above.
       MSG
 
       raise ReactOnRails::Error, msg
     end
 
-    def self.raise_shakapacker_not_installed
+    def self.raise_shakapacker_version_incompatible_for_basic_pack_generation
       msg = <<~MSG
-        **ERROR** ReactOnRails: Missing Shakapacker gem. Please upgrade to use Shakapacker \
-        #{semver_to_string(ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION)} or above to use the \
-        automated bundle generation feature.
+        **ERROR** ReactOnRails: Please upgrade ::Shakapacker to version #{ReactOnRails::PacksGenerator::MINIMUM_SHAKAPACKER_VERSION} or \
+        above to use basic pack generation features. The currently installed version is #{ReactOnRails::PackerUtils.shakapacker_version}.
       MSG
 
       raise ReactOnRails::Error, msg
     end
-
-    def self.semver_to_string(ary)
-      "#{ary[0]}.#{ary[1]}.#{ary[2]}"
-    end
   end
 end

data/lib/react_on_rails/packs_generator.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "set"
 
 module ReactOnRails
   # rubocop:disable Metrics/ClassLength
   class PacksGenerator
     CONTAINS_CLIENT_OR_SERVER_REGEX = /\.(server|client)($|\.)/
-    MINIMUM_SHAKAPACKER_VERSION = [6, 5, 1].freeze
+    COMPONENT_EXTENSIONS = /\.(jsx?|tsx?)$/
+    MINIMUM_SHAKAPACKER_VERSION = "6.5.1"
+    # Auto-registration requires nested_entries support which was added in 7.0.0
+    MINIMUM_SHAKAPACKER_VERSION_FOR_AUTO_BUNDLING = "7.0.0"
 
     def self.instance
       @instance ||= PacksGenerator.new
@@ -16,13 +20,20 @@ module ReactOnRails
       return unless ReactOnRails.configuration.auto_load_bundle
 
       add_generated_pack_to_server_bundle
+
+      # Clean any non-generated files from directories
+      clean_non_generated_files_with_feedback
+
       are_generated_files_present_and_up_to_date = Dir.exist?(generated_packs_directory_path) &&
                                                    File.exist?(generated_server_bundle_file_path) &&
                                                    !stale_or_missing_packs?
 
-      return if are_generated_files_present_and_up_to_date
+      if are_generated_files_present_and_up_to_date
+        puts Rainbow("✅ Generated packs are up to date, no regeneration needed").green
+        return
+      end
 
-      clean_generated_packs_directory
+      clean_generated_directories_with_feedback
       generate_packs
     end
 
@@ -44,11 +55,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
+      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_from_generated_pack(file_path)}';
+        import #{registered_component_name} from '#{relative_component_path}';
 
         ReactOnRails.register({#{registered_component_name}});
       FILE_CONTENT
@@ -61,27 +127,46 @@ 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
+      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
 
-      <<~FILE_CONTENT
-        import ReactOnRails from 'react-on-rails';
-
-        #{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
       return if ReactOnRails.configuration.make_generated_server_bundle_the_entrypoint
+      return if ReactOnRails.configuration.server_bundle_js_file.blank?
 
       relative_path_to_generated_server_bundle = relative_path(server_bundle_entrypoint,
                                                                generated_server_bundle_file_path)
@@ -109,9 +194,112 @@ module ReactOnRails
       "#{generated_nonentrypoints_path}/#{generated_server_bundle_file_name}.js"
     end
 
-    def clean_generated_packs_directory
-      FileUtils.rm_rf(generated_packs_directory_path)
-      FileUtils.mkdir_p(generated_packs_directory_path)
+    def clean_non_generated_files_with_feedback
+      directories_to_clean = [generated_packs_directory_path, generated_server_bundle_directory_path].compact.uniq
+      expected_files = build_expected_files_set
+
+      puts Rainbow("🧹 Cleaning non-generated files...").yellow
+
+      total_deleted = directories_to_clean.sum do |dir_path|
+        clean_unexpected_files_from_directory(dir_path, expected_files)
+      end
+
+      display_cleanup_summary(total_deleted)
+    end
+
+    def build_expected_files_set
+      expected_pack_files = Set.new
+      common_component_to_path.each_value { |path| expected_pack_files << generated_pack_path(path) }
+      client_component_to_path.each_value { |path| expected_pack_files << generated_pack_path(path) }
+
+      if ReactOnRails.configuration.server_bundle_js_file.present?
+        expected_server_bundle = generated_server_bundle_file_path
+      end
+
+      { pack_files: expected_pack_files, server_bundle: expected_server_bundle }
+    end
+
+    def clean_unexpected_files_from_directory(dir_path, expected_files)
+      return 0 unless Dir.exist?(dir_path)
+
+      existing_files = Dir.glob("#{dir_path}/**/*").select { |f| File.file?(f) }
+      unexpected_files = find_unexpected_files(existing_files, dir_path, expected_files)
+
+      if unexpected_files.any?
+        delete_unexpected_files(unexpected_files, dir_path)
+        unexpected_files.length
+      else
+        puts Rainbow("   No unexpected files found in #{dir_path}").cyan
+        0
+      end
+    end
+
+    def find_unexpected_files(existing_files, dir_path, expected_files)
+      existing_files.reject do |file|
+        if dir_path == generated_server_bundle_directory_path
+          file == expected_files[:server_bundle]
+        else
+          expected_files[:pack_files].include?(file)
+        end
+      end
+    end
+
+    def delete_unexpected_files(unexpected_files, dir_path)
+      puts Rainbow("   Deleting #{unexpected_files.length} unexpected files from #{dir_path}:").cyan
+      unexpected_files.each do |file|
+        puts Rainbow("     - #{File.basename(file)}").blue
+        File.delete(file)
+      end
+    end
+
+    def display_cleanup_summary(total_deleted)
+      if total_deleted.positive?
+        puts Rainbow("🗑️  Deleted #{total_deleted} unexpected files total").red
+      else
+        puts Rainbow("✨ No unexpected files to delete").green
+      end
+    end
+
+    def clean_generated_directories_with_feedback
+      directories_to_clean = [
+        generated_packs_directory_path,
+        generated_server_bundle_directory_path
+      ].compact.uniq
+
+      puts Rainbow("🧹 Cleaning generated directories...").yellow
+
+      total_deleted = directories_to_clean.sum { |dir_path| clean_directory_with_feedback(dir_path) }
+
+      if total_deleted.positive?
+        puts Rainbow("🗑️  Deleted #{total_deleted} generated files total").red
+      else
+        puts Rainbow("✨ No files to delete, directories are clean").green
+      end
+    end
+
+    def clean_directory_with_feedback(dir_path)
+      return create_directory_with_feedback(dir_path) unless Dir.exist?(dir_path)
+
+      files = Dir.glob("#{dir_path}/**/*").select { |f| File.file?(f) }
+
+      if files.any?
+        puts Rainbow("   Deleting #{files.length} files from #{dir_path}:").cyan
+        files.each { |file| puts Rainbow("     - #{File.basename(file)}").blue }
+        FileUtils.rm_rf(dir_path)
+        FileUtils.mkdir_p(dir_path)
+        files.length
+      else
+        puts Rainbow("   Directory #{dir_path} is already empty").cyan
+        FileUtils.rm_rf(dir_path)
+        FileUtils.mkdir_p(dir_path)
+        0
+      end
+    end
+
+    def create_directory_with_feedback(dir_path)
+      puts Rainbow("   Directory #{dir_path} does not exist, creating...").cyan
+      FileUtils.mkdir_p(dir_path)
+      0
     end
 
     def server_bundle_entrypoint
@@ -125,6 +313,13 @@ module ReactOnRails
       "#{source_entry_path}/generated"
     end
 
+    def generated_server_bundle_directory_path
+      return nil if ReactOnRails.configuration.make_generated_server_bundle_the_entrypoint
+
+      source_entrypoint_parent = Pathname(ReactOnRails::PackerUtils.packer_source_entry_path).parent
+      "#{source_entrypoint_parent}/generated"
+    end
+
     def relative_component_path_from_generated_pack(ror_component_path)
       component_file_pathname = Pathname.new(ror_component_path)
       component_generated_pack_path = generated_pack_path(ror_component_path)
@@ -155,14 +350,20 @@ module ReactOnRails
       paths.to_h { |path| [component_name(path), path] }
     end
 
+    def filter_component_files(paths)
+      paths.grep(COMPONENT_EXTENSIONS)
+    end
+
     def common_component_to_path
       common_components_paths = Dir.glob("#{components_search_path}/*").grep_v(CONTAINS_CLIENT_OR_SERVER_REGEX)
-      component_name_to_path(common_components_paths)
+      filtered_paths = filter_component_files(common_components_paths)
+      component_name_to_path(filtered_paths)
     end
 
     def client_component_to_path
       client_render_components_paths = Dir.glob("#{components_search_path}/*.client.*")
-      client_specific_components = component_name_to_path(client_render_components_paths)
+      filtered_client_paths = filter_component_files(client_render_components_paths)
+      client_specific_components = component_name_to_path(filtered_client_paths)
 
       duplicate_components = common_component_to_path.slice(*client_specific_components.keys)
       duplicate_components.each_key { |component| raise_client_component_overrides_common(component) }
@@ -172,7 +373,8 @@ module ReactOnRails
 
     def server_component_to_path
       server_render_components_paths = Dir.glob("#{components_search_path}/*.server.*")
-      server_specific_components = component_name_to_path(server_render_components_paths)
+      filtered_server_paths = filter_component_files(server_render_components_paths)
+      server_specific_components = component_name_to_path(filtered_server_paths)
 
       duplicate_components = common_component_to_path.slice(*server_specific_components.keys)
       duplicate_components.each_key { |component| raise_server_component_overrides_common(component) }

data/lib/react_on_rails/prerender_error.rb

@@ -83,6 +83,10 @@ module ReactOnRails
         MSG
 
       end
+
+      # Add help and support information
+      message << "\n#{Utils.default_troubleshooting_section}\n"
+
       [backtrace, message]
     end
   end

data/lib/react_on_rails/pro/NOTICE

@@ -0,0 +1,21 @@
+# React on Rails Pro License
+
+The files in this directory and its subdirectories are licensed under the **React on Rails Pro** license, which is separate from the MIT license that covers the core React on Rails functionality.
+
+## License Terms
+
+These files are proprietary software and are **NOT** covered by the MIT license found in the root LICENSE.md file. Usage requires a valid React on Rails Pro license.
+
+## Distribution
+
+Files in this directory will be **omitted** from future distributions of the open source React on Rails Ruby gem. They are exclusively available to React on Rails Pro licensees.
+
+## License Reference
+
+For the complete React on Rails Pro license terms, see: `REACT-ON-RAILS-PRO-LICENSE.md` in the root directory of this repository.
+
+## More Information
+
+For React on Rails Pro licensing information and to obtain a license, please visit:
+- [React on Rails Pro](https://www.shakacode.com/react-on-rails-pro/)
+- Contact: [react_on_rails@shakacode.com](mailto:react_on_rails@shakacode.com)