Move Pro Ruby code to MIT license

LICENSE.md

@@ -11,15 +11,14 @@ This repository contains code under two different licenses:
 
 The following directories and all their contents are licensed under the **MIT License** (see full text below):
 
-- `lib/react_on_rails/` (excluding `lib/react_on_rails/pro/`)
+- `lib/react_on_rails/` (entire directory)
 - `packages/react-on-rails/` (entire package)
 - All other directories in this repository not explicitly listed as Pro-licensed
 
 ### Pro Licensed Code
 
 The following directories and all their contents are licensed under the **React on Rails Pro License**:
 
-- `lib/react_on_rails/pro/`
 - `packages/react-on-rails-pro/` (entire package)
 - `react_on_rails_pro/` (entire directory)
 

docs/MONOREPO_MERGER_PLAN.md

@@ -372,12 +372,11 @@ After the initial merge, the following CI adjustments may be needed:
   ```md
   ## MIT License applies to:
 
-  - `lib/react_on_rails/` (excluding `lib/react_on_rails/pro/`)
+  - `lib/react_on_rails/` (entire directory)
   - `packages/react-on-rails/` (entire package)
 
   ## React on Rails Pro License applies to:
 
-  - `lib/react_on_rails/pro/`
   - `packages/react-on-rails-pro/` (entire package)
   - `react_on_rails_pro/` (entire directory)
   ```

lib/react_on_rails/helper.rb

@@ -11,12 +11,12 @@
 require "react_on_rails/utils"
 require "react_on_rails/json_output"
 require "active_support/concern"
-require "react_on_rails/pro/helper"
+require "react_on_rails/pro_helper"
 
 module ReactOnRails
   module Helper
     include ReactOnRails::Utils::Required
-    include ReactOnRails::Pro::Helper
+    include ReactOnRails::ProHelper
 
     COMPONENT_HTML_KEY = "componentHtml"
 

lib/react_on_rails/pro_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  module ProHelper
+    # Generates the complete component specification script tag.
+    # Handles both immediate hydration (Pro feature) and standard cases.
+    def generate_component_script(render_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.
+      component_specification_tag = content_tag(:script,
+                                                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-store-dependencies" =>
+                                                  render_options.store_dependencies&.to_json,
+                                                "data-immediate-hydration" =>
+                                                  (render_options.immediate_hydration ? true : nil))
+
+      # Add immediate invocation script if immediate hydration is enabled
+      if render_options.immediate_hydration
+        # Escape dom_id for JavaScript context
+        escaped_dom_id = escape_javascript(render_options.dom_id)
+        immediate_script = content_tag(:script, %(
+  typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsComponentLoaded('#{escaped_dom_id}');
+).html_safe)
+        "#{component_specification_tag}\n#{immediate_script}".html_safe
+      else
+        component_specification_tag
+      end
+    end
+
+    # Generates the complete store hydration script tag.
+    # Handles both immediate hydration (Pro feature) and standard cases.
+    def generate_store_script(redux_store_data)
+      pro_options_check_result = ReactOnRails::ProUtils.disable_pro_render_options_if_not_licensed(redux_store_data)
+      redux_store_data = pro_options_check_result[:raw_options]
+
+      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-immediate-hydration" =>
+                                           (redux_store_data[:immediate_hydration] ? true : nil))
+
+      # Add immediate invocation script if immediate hydration is enabled and Pro license is valid
+      if redux_store_data[:immediate_hydration]
+        # Escape store_name for JavaScript context
+        escaped_store_name = escape_javascript(redux_store_data[:store_name])
+        immediate_script = content_tag(:script, <<~JS.strip_heredoc.html_safe
+          typeof ReactOnRails === 'object' && ReactOnRails.reactOnRailsStoreLoaded('#{escaped_store_name}');
+        JS
+        )
+        "#{store_hydration_data}\n#{immediate_script}".html_safe
+      else
+        store_hydration_data
+      end
+    end
+  end
+end

lib/react_on_rails/pro_utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  module ProUtils
+    PRO_ONLY_OPTIONS = %i[immediate_hydration].freeze
+
+    # Checks if React on Rails Pro features are available
+    # @return [Boolean] true if Pro license is valid, false otherwise
+    def self.support_pro_features?
+      ReactOnRails::Utils.react_on_rails_pro_licence_valid?
+    end
+
+    def self.disable_pro_render_options_if_not_licensed(raw_options)
+      if support_pro_features?
+        return {
+          raw_options: raw_options,
+          explicitly_disabled_pro_options: []
+        }
+      end
+
+      raw_options_after_disable = raw_options.dup
+
+      explicitly_disabled_pro_options = PRO_ONLY_OPTIONS.select do |option|
+        # Use global configuration if it's not overridden in the options
+        next ReactOnRails.configuration.send(option) if raw_options[option].nil?
+
+        raw_options[option]
+      end
+      explicitly_disabled_pro_options.each { |option| raw_options_after_disable[option] = false }
+
+      {
+        raw_options: raw_options_after_disable,
+        explicitly_disabled_pro_options: explicitly_disabled_pro_options
+      }
+    end
+  end
+end

lib/react_on_rails/react_component/render_options.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "react_on_rails/utils"
-require "react_on_rails/pro/utils"
+require "react_on_rails/pro_utils"
 
 module ReactOnRails
   module ReactComponent
@@ -16,7 +16,7 @@ class RenderOptions
       def initialize(react_component_name: required("react_component_name"), options: required("options"))
         @react_component_name = react_component_name.camelize
 
-        result = ReactOnRails::Pro::Utils.disable_pro_render_options_if_not_licensed(options)
+        result = ReactOnRails::ProUtils.disable_pro_render_options_if_not_licensed(options)
         @options = result[:raw_options]
         @explicitly_disabled_pro_options = result[:explicitly_disabled_pro_options]
       end