react_on_rails_pro 16.2.0.beta.8

data/rakelib/public_key_management.rake

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+# React on Rails Pro License Public Key Management Tasks
+#
+# Usage:
+#   rake react_on_rails_pro:update_public_key              # From production (shakacode.com)
+#   rake react_on_rails_pro:update_public_key[local]       # From localhost:8788
+#   rake react_on_rails_pro:update_public_key[custom.com]  # From custom hostname
+#   rake react_on_rails_pro:verify_public_key              # Verify current configuration
+#   rake react_on_rails_pro:public_key_help                # Show help
+
+namespace :react_on_rails_pro do # rubocop:disable Metrics/BlockLength
+  desc "Update the public key for React on Rails Pro license validation"
+  task :update_public_key, [:source] do |_task, args| # rubocop:disable Metrics/BlockLength
+    source = args[:source] || "production"
+
+    # Determine the API URL based on the source
+    api_url = case source
+              when "local", "localhost"
+                # Use the default local URL created by the Cloudflare Wrangler tool when the worker is run locally
+                "http://localhost:8788/api/public-key"
+              when "production", "prod"
+                "https://www.shakacode.com/api/public-key"
+              else
+                # Check if it's a custom URL or hostname
+                if source.start_with?("http://", "https://")
+                  # Full URL provided
+                  source.end_with?("/api/public-key") ? source : "#{source}/api/public-key"
+                else
+                  # Just a hostname provided
+                  "https://#{source}/api/public-key"
+                end
+              end
+
+    puts "Fetching public key from: #{api_url}"
+
+    begin
+      uri = URI(api_url)
+      response = Net::HTTP.get_response(uri)
+
+      if response.code != "200"
+        puts "❌ Failed to fetch public key. HTTP Status: #{response.code}"
+        puts "Response: #{response.body}"
+        exit 1
+      end
+
+      data = JSON.parse(response.body)
+      public_key = data["publicKey"]
+
+      if public_key.nil? || public_key.empty?
+        puts "❌ No public key found in response"
+        exit 1
+      end
+
+      # TODO: Add a prepublish check to ensure this key matches the latest public key from the API.
+      # This should be implemented after publishing the API endpoint on the ShakaCode website.
+      # Update Ruby public key file
+      ruby_file_path = File.join(File.dirname(__FILE__), "..", "lib", "react_on_rails_pro", "license_public_key.rb")
+      ruby_content = <<~RUBY.strip_heredoc
+        # frozen_string_literal: true
+
+        module ReactOnRailsPro
+          module LicensePublicKey
+            # ShakaCode's public key for React on Rails Pro license verification
+            # The private key corresponding to this public key is held by ShakaCode
+            # and is never committed to the repository
+            # Last updated: #{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S UTC')}
+            # Source: #{api_url}
+            #
+            # You can update this public key by running the rake task:
+            #   react_on_rails_pro:update_public_key
+            # This task fetches the latest key from the API endpoint:
+            #   http://shakacode.com/api/public-key
+            KEY = OpenSSL::PKey::RSA.new(<<~PEM.strip.strip_heredoc)
+              #{public_key.strip}
+            PEM
+          end
+        end
+      RUBY
+
+      File.write(ruby_file_path, ruby_content)
+      puts "✅ Updated Ruby public key: #{ruby_file_path}"
+
+      # Update Node/TypeScript public key file
+      node_file_path = File.join(File.dirname(__FILE__), "..", "packages", "node-renderer", "src", "shared",
+                                 "licensePublicKey.ts")
+      node_content = <<~TYPESCRIPT
+        // ShakaCode's public key for React on Rails Pro license verification
+        // The private key corresponding to this public key is held by ShakaCode
+        // and is never committed to the repository
+        // Last updated: #{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S UTC')}
+        // Source: #{api_url}
+        //
+        // You can update this public key by running the rake task:
+        //   react_on_rails_pro:update_public_key
+        // This task fetches the latest key from the API endpoint:
+        //   http://shakacode.com/api/public-key
+        export const PUBLIC_KEY = `#{public_key.strip}`;
+      TYPESCRIPT
+
+      File.write(node_file_path, node_content)
+      puts "✅ Updated Node public key: #{node_file_path}"
+
+      puts "\n✅ Successfully updated public keys from #{api_url}"
+      puts "\nPublic key info:"
+      puts "  Algorithm: #{data['algorithm'] || 'RSA-2048'}"
+      puts "  Format: #{data['format'] || 'PEM'}"
+      puts "  Usage: #{data['usage'] || 'React on Rails Pro license verification'}"
+    rescue SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+      puts "❌ Network error: #{e.message}"
+      puts "Please check your internet connection and the API URL."
+      exit 1
+    rescue JSON::ParserError => e
+      puts "❌ Failed to parse JSON response: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      puts "❌ Error: #{e.message}"
+      puts e.backtrace.first(5)
+      exit 1
+    end
+  end
+
+  desc "Show usage examples for updating the public key"
+  task :public_key_help do
+    puts <<~HELP
+      React on Rails Pro - Public Key Management
+      ==========================================
+
+      Update public key from different sources:
+
+      1. From production (ShakaCode's official server):
+         rake react_on_rails_pro:update_public_key
+         rake react_on_rails_pro:update_public_key[production]
+
+      2. From local development server:
+         rake react_on_rails_pro:update_public_key[local]
+
+      3. From a custom hostname:
+         rake react_on_rails_pro:update_public_key[staging.example.com]
+
+      4. From a custom full URL:
+         rake react_on_rails_pro:update_public_key[https://api.example.com/api/public-key]
+
+      Verify current public key:
+         rake react_on_rails_pro:verify_public_key
+
+      Note: The public key is used to verify JWT licenses for React on Rails Pro.
+            The corresponding private key is held securely by ShakaCode.
+    HELP
+  end
+end

data/rakelib/rbs.rake

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+# NOTE: Pro package does not include Steep tasks (:steep, :all) as it does not
+# use Steep type checker. Only RBS validation is performed.
+# rubocop:disable Metrics/BlockLength
+namespace :rbs do
+  desc "Validate RBS type signatures"
+  task :validate do
+    require "rbs"
+    require "rbs/cli"
+
+    puts "Validating RBS type signatures..."
+
+    # Use Open3 for better error handling - captures stdout, stderr, and exit status separately
+    # This allows us to distinguish between actual validation errors and warnings
+    # Note: Must use bundle exec even though rake runs in bundle context because
+    # spawned shell commands via Open3.capture3() do NOT inherit bundle context
+    # Wrap in Timeout to prevent hung processes in CI environments (60 second timeout)
+    stdout, stderr, status = Timeout.timeout(60) do
+      Open3.capture3("bundle exec rbs -I sig validate")
+    end
+
+    if status.success?
+      puts "✓ RBS validation passed"
+    else
+      puts "✗ RBS validation failed"
+      puts stdout unless stdout.empty?
+      warn stderr unless stderr.empty?
+      exit 1
+    end
+  end
+
+  desc "Check RBS type signatures (alias for validate)"
+  task check: :validate
+
+  desc "List all RBS files"
+  task :list do
+    sig_files = Dir.glob("sig/**/*.rbs")
+    puts "RBS type signature files:"
+    sig_files.each { |f| puts "  #{f}" }
+    puts "\nTotal: #{sig_files.count} files"
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/rakelib/run_rspec.rake

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# TODO: This file is not used for CI
+require "coveralls/rake/task" if ENV["USE_COVERALLS"] == "TRUE"
+
+require "pathname"
+require "active_support/core_ext/string"
+require_relative "task_helpers"
+namespace :run_rspec do
+  include ReactOnRailsPro::TaskHelpers
+
+  spec_dummy_dir = File.join("spec", "dummy")
+
+  desc "Run RSpec for top level only"
+  task :gem do
+    run_tests_in("", rspec_args: File.join("spec", "react_on_rails_pro"))
+  end
+
+  desc "Runs dummy rspec"
+  task dummy: ["dummy_app:dummy_app"] do
+    clean_gen_assets(spec_dummy_dir)
+    bundle_install_in(dummy_app_dir)
+    run_tests_in(spec_dummy_dir)
+  end
+
+  desc "(HACK) Run RSpec on spec/empty_spec in order to have SimpleCov generate a coverage report from cache"
+  task :empty do
+    sh %(#{ENV['USE_COVERALLS'] ? 'COVERAGE=true' : ''} rspec spec/empty_spec.rb)
+  end
+
+  Coveralls::RakeTask.new if ENV["USE_COVERALLS"] == "TRUE"
+
+  desc "run all tests"
+  task run_rspec: %i[gem dummy empty js_tests] do
+    puts "Completed all RSpec tests"
+  end
+end
+
+desc "js tests (same as 'yarn run test')"
+task :js_tests do
+  sh "yarn run test"
+end
+
+msg = <<-DESC.strip_heredoc
+  Runs all tests, run `rake -D run_rspec` to see all available test options.
+DESC
+desc msg
+task run_rspec: ["run_rspec:run_rspec"]
+
+private
+
+def calc_path(dir)
+  if dir.is_a?(String)
+    if dir.start_with?(File::SEPARATOR)
+      Pathname.new(dir)
+    else
+      Pathname.new(File.join(gem_root, dir))
+    end
+  else
+    dir
+  end
+end
+
+# Runs rspec in the given directory.
+# If string is passed and it's not absolute, it's converted relative to root of the gem.
+# TEST_ENV_COMMAND_NAME is used to make SimpleCov.command_name unique in order to
+# prevent a name collision. Defaults to the given directory's name.
+def run_tests_in(dir, options = {})
+  path = calc_path(dir)
+
+  command_name = options.fetch(:command_name, path.basename)
+  rspec_args = options.fetch(:rspec_args, "")
+  env_vars = +"#{options.fetch(:env_vars, '')} TEST_ENV_COMMAND_NAME=\"#{command_name}\""
+  env_vars << "COVERAGE=true" if ENV["USE_COVERALLS"]
+  sh_in_dir(path.realpath, "#{env_vars} bundle exec rspec #{rspec_args}")
+end
+
+def clean_gen_assets(dir)
+  path = calc_path(dir)
+  sh_in_dir(path.realpath, "yarn run build:clean")
+end

data/rakelib/task_helpers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  module TaskHelpers
+    # Returns the root folder of the react_on_rails gem
+    def gem_root
+      File.expand_path("..", __dir__)
+    end
+
+    def dummy_app_dir
+      File.join(gem_root, "spec/dummy")
+    end
+
+    # Executes a string or an array of strings in a shell in the given directory
+    def sh_in_dir(dir, *shell_commands)
+      Dir.chdir(dir) do
+        # Without `with_unbundled_env`, running bundle in the child directories won't correctly
+        # update the Gemfile.lock
+        Bundler.with_unbundled_env do
+          shell_commands.flatten.each do |shell_command|
+            sh(shell_command.strip)
+          end
+        end
+      end
+    end
+
+    def bundle_install_in(dir, frozen: true)
+      cmd = "#{frozen ? 'BUNDLE_FROZEN=true ' : ''}bundle install"
+      sh_in_dir(dir, cmd)
+    end
+
+    # Runs bundle exec using that directory's Gemfile
+    def bundle_exec(dir: nil, args: nil, env_vars: "")
+      sh_in_dir(dir, "#{env_vars} #{args}")
+    end
+
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), new_hash|
+        new_key = key.is_a?(String) ? key.to_sym : key
+        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+        new_hash[new_key] = new_value
+      end
+    end
+  end
+end

data/rakelib/yard.rake

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "yard"
+require "commonmarker"
+
+class GithubMarkdown
+  attr_reader :to_html
+
+  def initialize(text)
+    @to_html = CommonMarker.render_html(text)
+  end
+end
+
+YARD::Rake::YardocTask.new do |t|
+  helper = YARD::Templates::Helpers::MarkupHelper
+  helper.clear_markup_cache
+  helper::MARKUP_PROVIDERS[:markdown].unshift const: "GithubMarkdown"
+  t.files = %w[lib/react_on_rails_pro/utils.rb app/helpers/react_on_rails_pro_helper.rb]
+  t.options = ["-o", "gen-documentation", "-r", "readme-gen-docs.md"]
+end

data/react_on_rails_pro.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "react_on_rails_pro/version"
+
+# Load the core react_on_rails version for dependency
+# This is evaluated at build time, not on user machines
+require_relative "../lib/react_on_rails/version"
+
+Gem::Specification.new do |s|
+  s.name          = "react_on_rails_pro"
+  s.version       = ReactOnRailsPro::VERSION
+  s.authors       = ["Justin Gordon"]
+  s.email         = ["justin@shakacode.com"]
+
+  s.summary       = "Rails with react server rendering with webpack. Performance helpers"
+  s.description   = "See README.md"
+  s.homepage      = "https://github.com/shakacode/react_on_rails_pro"
+  s.license       = "UNLICENSED"
+  s.metadata["rubygems_mfa_required"] = "true"
+
+  s.files         = `git ls-files -z`.split("\x0")
+                                     .reject { |f|
+                                       f.match(
+                                         %r{^(test|spec|features|tmp|node_modules|packages|coverage|Gemfile.lock|lib/tasks)/}
+                                       )
+                                     }
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 3.0"
+
+  s.add_runtime_dependency "addressable"
+  s.add_runtime_dependency "connection_pool"
+  s.add_runtime_dependency "execjs", "~> 2.9"
+  s.add_runtime_dependency "httpx", "~> 1.5"
+  s.add_runtime_dependency "jwt", "~> 2.7"
+  s.add_runtime_dependency "async", ">= 2.6"
+  s.add_runtime_dependency "rainbow"
+  s.add_runtime_dependency "react_on_rails", ReactOnRails::VERSION
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "commonmarker"
+  s.add_development_dependency "gem-release"
+  s.add_development_dependency "yard"
+end

data/readme-gen-docs.md

@@ -0,0 +1 @@
+[See documentation wiki](https://github.com/shakacode/react_on_rails/wiki)

data/script/bootstrap

@@ -0,0 +1,33 @@
+#!/bin/sh
+
+# script/bootstrap: Resolve all dependencies that the application requires to
+#                   run.
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ]; then
+  brew update
+
+  brew bundle check 2>&1 >/dev/null || {
+    echo "==> Installing Homebrew dependencies…"
+    brew bundle
+  }
+fi
+
+if [ -f ".ruby-version" ] && [ -z "$(rbenv version-name 2>/dev/null)" ]; then
+  echo "==> Installing Ruby…"
+  rbenv install --skip-existing
+  which bundle 2>&1 >/dev/null || {
+    gem install bundler
+    rbenv rehash
+  }
+fi
+
+if [ -f "Gemfile" ]; then
+  echo "==> Installing gem dependencies…"
+  bundle check --path vendor/gems 2>&1 >/dev/null || {
+    BUNDLE_FROZEN=true bundle install --path vendor/gems --quiet --without production
+  }
+fi

data/script/preinstall.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const cp = require('child_process');
+
+const inNodeModules = __dirname.split(path.sep).includes('node_modules');
+
+if (inNodeModules) {
+  console.log('preinstall: running inside node_modules — skipping link steps.');
+  process.exit(0);
+}
+
+function runCommand(cmd, args) {
+  const res = cp.spawnSync(cmd, args, { stdio: 'inherit' });
+  if (res.error) throw res.error;
+  if (res.status !== 0) throw new Error(`${cmd} ${args.join(' ')} exited with status ${res.status}`);
+}
+
+try {
+  // Run the original optional link steps sequentially in a cross-platform way.
+  // First run the package script `link-source` via yarn, which will run any shell ops inside the script
+  // (yarn itself will handle invoking a shell for the script body), then call yalc.
+  runCommand('yarn', ['run', 'link-source']);
+  runCommand('yalc', ['add', '--link', 'react-on-rails']);
+} catch (err) {
+  // Don't fail the overall install if these optional commands aren't available or fail,
+  // just log the error.
+  console.error('preinstall: optional link steps failed or are unavailable — continuing.', err);
+  // Keep the exit code 0 so the install doesn't fail.
+  process.exit(0);
+}

data/script/setup

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+# script/setup: Set up application for the first time after cloning, or set it
+#               back to the initial first unused state.
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+script/bootstrap
+
+echo "===> Setting up DB..."
+# reset database to a fresh state.
+bin/rake db:create db:reset
+
+if [ -z "$RAILS_ENV" ] && [ -z "$RACK_ENV" ]; then
+  # Only things for a development environment will run inside here
+  # Do things that need to be done to the application to set up for the first
+  # time. Or things needed to be run to to reset the application back to first
+  # use experience. These things are scoped to the application's domain.
+fi
+
+echo "==> App is now ready to go!"

data/script/test

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+# script/test: Run test suite for application. Optionally pass in a path to an
+#              individual test file to run a single test.
+
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+[ -z "$DEBUG" ] || set -x
+
+export RACK_ROOT=$(cd "$(dirname $0)"/.. && pwd)
+
+if [ "$RAILS_ENV" = "test" ] || [ "$RACK_ENV" = "test" ]; then
+  # if executed and the environment is already set to `test`, then we want a
+  # clean from scratch application. This almost always means a ci environment,
+  # since we set the environment to `test` directly in `script/cibuild`.
+  script/setup
+else
+  # if the environment isn't set to `test`, set it to `test` and update the
+  # application to ensure all dependencies are met as well as any other things
+  # that need to be up to date, like db migrations. The environement not having
+  # already been set to `test` almost always means this is being called on it's
+  # own from a `development` environment.
+  export RAILS_ENV="test" RACK_ENV="test"
+
+  script/update
+fi
+
+echo "===> Running tests..."
+
+if [ -n "$1" ]; then
+  # pass arguments to test call. This is useful for calling a single test.
+  bin/rake test "$1"
+else
+  bin/rake test
+fi

data/sig/react_on_rails_pro/cache.rbs

@@ -0,0 +1,13 @@
+module ReactOnRailsPro
+  class Cache
+    def self.fetch_react_component: (String component_name, Hash[Symbol, untyped] options) { () -> untyped } -> untyped
+
+    def self.use_cache?: (Hash[Symbol, untyped] options) -> bool
+
+    def self.base_cache_key: (String type, ?prerender: bool?) -> Array[String]
+
+    def self.dependencies_cache_key: () -> String?
+
+    def self.react_component_cache_key: (String component_name, Hash[Symbol, untyped] options) -> Array[untyped]
+  end
+end

data/sig/react_on_rails_pro/configuration.rbs

@@ -0,0 +1,100 @@
+module ReactOnRailsPro
+  class Configuration
+    DEFAULT_RENDERER_URL: String
+    DEFAULT_RENDERER_METHOD: String
+    DEFAULT_RENDERER_FALLBACK_EXEC_JS: bool
+    DEFAULT_RENDERER_HTTP_POOL_SIZE: Integer
+    DEFAULT_RENDERER_HTTP_POOL_TIMEOUT: Integer
+    DEFAULT_RENDERER_HTTP_POOL_WARN_TIMEOUT: Float
+    DEFAULT_SSR_TIMEOUT: Integer
+    DEFAULT_PRERENDER_CACHING: bool
+    DEFAULT_TRACING: bool
+    DEFAULT_DEPENDENCY_GLOBS: Array[String]
+    DEFAULT_EXCLUDED_DEPENDENCY_GLOBS: Array[String]
+    DEFAULT_REMOTE_BUNDLE_CACHE_ADAPTER: nil
+    DEFAULT_RENDERER_REQUEST_RETRY_LIMIT: Integer
+    DEFAULT_THROW_JS_ERRORS: bool
+    DEFAULT_RENDERING_RETURNS_PROMISES: bool
+    DEFAULT_PROFILE_SERVER_RENDERING_JS_CODE: bool
+    DEFAULT_RAISE_NON_SHELL_SERVER_RENDERING_ERRORS: bool
+    DEFAULT_ENABLE_RSC_SUPPORT: bool
+    DEFAULT_RSC_PAYLOAD_GENERATION_URL_PATH: String
+    DEFAULT_RSC_BUNDLE_JS_FILE: String
+    DEFAULT_REACT_CLIENT_MANIFEST_FILE: String
+    DEFAULT_REACT_SERVER_CLIENT_MANIFEST_FILE: String
+
+    attr_accessor renderer_url: String?
+    attr_accessor renderer_password: String?
+    attr_accessor tracing: bool?
+    attr_accessor server_renderer: String?
+    attr_accessor renderer_use_fallback_exec_js: bool?
+    attr_accessor prerender_caching: bool?
+    attr_accessor renderer_http_pool_size: Integer?
+    attr_accessor renderer_http_pool_timeout: Integer?
+    attr_accessor renderer_http_pool_warn_timeout: Float?
+    attr_accessor dependency_globs: Array[String]?
+    attr_accessor excluded_dependency_globs: Array[String]?
+    attr_accessor rendering_returns_promises: bool?
+    attr_accessor remote_bundle_cache_adapter: Module?
+    attr_accessor ssr_pre_hook_js: String?
+    attr_accessor assets_to_copy: Array[String]?
+    attr_accessor renderer_request_retry_limit: Integer?
+    attr_accessor throw_js_errors: bool?
+    attr_accessor ssr_timeout: Integer?
+    attr_accessor profile_server_rendering_js_code: bool?
+    attr_accessor raise_non_shell_server_rendering_errors: bool?
+    attr_accessor enable_rsc_support: bool?
+    attr_accessor rsc_payload_generation_url_path: String?
+    attr_accessor rsc_bundle_js_file: String?
+    attr_accessor react_client_manifest_file: String?
+    attr_accessor react_server_client_manifest_file: String?
+
+    def initialize: (
+      ?renderer_url: String?,
+      ?renderer_password: String?,
+      ?server_renderer: String?,
+      ?renderer_use_fallback_exec_js: bool?,
+      ?prerender_caching: bool?,
+      ?renderer_http_pool_size: Integer?,
+      ?renderer_http_pool_timeout: Integer?,
+      ?renderer_http_pool_warn_timeout: Float?,
+      ?tracing: bool?,
+      ?dependency_globs: Array[String]?,
+      ?excluded_dependency_globs: Array[String]?,
+      ?rendering_returns_promises: bool?,
+      ?remote_bundle_cache_adapter: Module?,
+      ?ssr_pre_hook_js: String?,
+      ?assets_to_copy: Array[String]?,
+      ?renderer_request_retry_limit: Integer?,
+      ?throw_js_errors: bool?,
+      ?ssr_timeout: Integer?,
+      ?profile_server_rendering_js_code: bool?,
+      ?raise_non_shell_server_rendering_errors: bool?,
+      ?enable_rsc_support: bool?,
+      ?rsc_payload_generation_url_path: String?,
+      ?rsc_bundle_js_file: String?,
+      ?react_client_manifest_file: String?,
+      ?react_server_client_manifest_file: String?
+    ) -> void
+
+    def setup_config_values: () -> void
+
+    def check_react_on_rails_support_for_rsc: () -> void
+
+    def setup_execjs_profiler_if_needed: () -> void
+
+    def node_renderer?: () -> bool
+
+    private
+
+    def setup_assets_to_copy: () -> void
+
+    def configure_default_url_if_not_provided: () -> void
+
+    def validate_url: () -> void
+
+    def validate_remote_bundle_cache_adapter: () -> void
+
+    def setup_renderer_password: () -> void
+  end
+end

data/sig/react_on_rails_pro/error.rbs

@@ -0,0 +1,4 @@
+module ReactOnRailsPro
+  class Error < StandardError
+  end
+end

data/sig/react_on_rails_pro/utils.rbs

@@ -0,0 +1,7 @@
+module ReactOnRailsPro
+  module Utils
+    def self.bundle_js_file_path: (String bundle_name) -> String
+
+    def self.running_on_windows?: () -> bool
+  end
+end

data/sig/react_on_rails_pro.rbs

@@ -0,0 +1,5 @@
+module ReactOnRailsPro
+  def self.configure: () { (Configuration) -> void } -> void
+
+  def self.configuration: () -> Configuration
+end