react_on_rails 14.2.1 → 16.1.1

data/lib/react_on_rails/test_helper.rb

@@ -86,10 +86,9 @@ module ReactOnRails
           puts
           @printed_once = true
 
-          if ReactOnRails::PackerUtils.using_packer? &&
-             ReactOnRails::Utils.using_packer_source_path_is_not_defined_and_custom_node_modules?
+          if ReactOnRails::Utils.using_packer_source_path_is_not_defined_and_custom_node_modules?
             msg = <<-MSG.strip_heredoc
-              WARNING: Define config/#{ReactOnRails::PackerUtils.packer_type}.yml to include sourcePath to configure
+              WARNING: Define config/shakapacker.yml to include sourcePath to configure
               the location of your JavaScript source for React on Rails.
               Default location of #{source_path} is used.
             MSG

data/lib/react_on_rails/utils.rb

@@ -6,6 +6,7 @@ require "rainbow"
 require "active_support"
 require "active_support/core_ext/string"
 
+# rubocop:disable Metrics/ModuleLength
 module ReactOnRails
   module Utils
     TRUNCATION_FILLER = "\n... TRUNCATED #{
@@ -57,6 +58,8 @@ module ReactOnRails
         MSG
 
         puts wrap_message(msg)
+        puts ""
+        puts default_troubleshooting_section
 
         # Rspec catches exit without! in the exit callbacks
         exit!(1)
@@ -68,44 +71,107 @@ module ReactOnRails
       server_bundle_js_file_path =~ %r{https?://}
     end
 
+    def self.bundle_js_file_path(bundle_name)
+      # Priority order depends on bundle type:
+      # SERVER BUNDLES (normal case): Try private non-public locations first, then manifest, then legacy
+      # CLIENT BUNDLES (normal case): Try manifest first, then fallback locations
+      if bundle_name == "manifest.json"
+        # Default to the non-hashed name in the specified output directory, which, for legacy
+        # React on Rails, this is the output directory picked up by the asset pipeline.
+        # For Shakapacker, this is the public output path defined in the (shaka/web)packer.yml file.
+        File.join(public_bundles_full_path, bundle_name)
+      else
+        bundle_js_file_path_with_packer(bundle_name)
+      end
+    end
+
+    private_class_method def self.bundle_js_file_path_with_packer(bundle_name)
+      is_server_bundle = server_bundle?(bundle_name)
+      config = ReactOnRails.configuration
+      root_path = Rails.root || "."
+
+      # If server bundle and server_bundle_output_path is configured, return that path directly
+      if is_server_bundle && config.server_bundle_output_path.present?
+        private_server_bundle_path = File.expand_path(File.join(root_path, config.server_bundle_output_path,
+                                                                bundle_name))
+
+        # Don't fall back to public directory if enforce_private_server_bundles is enabled
+        if config.enforce_private_server_bundles || File.exist?(private_server_bundle_path)
+          return private_server_bundle_path
+        end
+      end
+
+      # Try manifest lookup for all bundles
+      begin
+        ReactOnRails::PackerUtils.bundle_js_uri_from_packer(bundle_name)
+      rescue Shakapacker::Manifest::MissingEntryError
+        handle_missing_manifest_entry(bundle_name, is_server_bundle)
+      end
+    end
+
+    private_class_method def self.server_bundle?(bundle_name)
+      config = ReactOnRails.configuration
+      bundle_name == config.server_bundle_js_file ||
+      bundle_name == config.rsc_bundle_js_file ||
+      bundle_name == config.react_server_client_manifest_file
+    end
+
+    private_class_method def self.handle_missing_manifest_entry(bundle_name, is_server_bundle)
+      config = ReactOnRails.configuration
+      root_path = Rails.root || "."
+
+      # For server bundles with server_bundle_output_path configured, use that
+      if is_server_bundle && config.server_bundle_output_path.present?
+        candidate_paths = [File.expand_path(File.join(root_path, config.server_bundle_output_path, bundle_name))]
+        unless config.enforce_private_server_bundles
+          candidate_paths << File.expand_path(File.join(ReactOnRails::PackerUtils.packer_public_output_path,
+                                                        bundle_name))
+        end
+
+        candidate_paths.each do |path|
+          return path if File.exist?(path)
+        end
+        return candidate_paths.first
+      end
+
+      # For client bundles and server bundles without special config, use packer's public path
+      # This returns the environment-specific path configured in shakapacker.yml
+      File.expand_path(File.join(ReactOnRails::PackerUtils.packer_public_output_path, bundle_name))
+    end
+
     def self.server_bundle_js_file_path
-      # Either:
-      # 1. Using same bundle for both server and client, so server bundle will be hashed in manifest
-      # 2. Using a different bundle (different Webpack config), so file is not hashed, and
-      #    bundle_js_path will throw so the default path is used without a hash.
-      # 3. The third option of having the server bundle hashed and a different configuration than
-      #    the client bundle is not supported for 2 reasons:
-      #    a. The webpack manifest plugin would have a race condition where the same manifest.json
-      #       is edited by both the webpack-dev-server
-      #    b. There is no good reason to hash the server bundle name.
       return @server_bundle_path if @server_bundle_path && !Rails.env.development?
 
       bundle_name = ReactOnRails.configuration.server_bundle_js_file
-      @server_bundle_path = if ReactOnRails::PackerUtils.using_packer?
-                              begin
-                                bundle_js_file_path(bundle_name)
-                              rescue Object.const_get(
-                                ReactOnRails::PackerUtils.packer_type.capitalize
-                              )::Manifest::MissingEntryError
-                                File.expand_path(
-                                  File.join(ReactOnRails::PackerUtils.packer_public_output_path,
-                                            bundle_name)
-                                )
-                              end
-                            else
-                              bundle_js_file_path(bundle_name)
-                            end
+      @server_bundle_path = bundle_js_file_path(bundle_name)
     end
 
-    def self.bundle_js_file_path(bundle_name)
-      if ReactOnRails::PackerUtils.using_packer? && bundle_name != "manifest.json"
-        ReactOnRails::PackerUtils.bundle_js_uri_from_packer(bundle_name)
-      else
-        # Default to the non-hashed name in the specified output directory, which, for legacy
-        # React on Rails, this is the output directory picked up by the asset pipeline.
-        # For Shakapacker, this is the public output path defined in the (shaka/web)packer.yml file.
-        File.join(generated_assets_full_path, bundle_name)
+    def self.rsc_bundle_js_file_path
+      return @rsc_bundle_path if @rsc_bundle_path && !Rails.env.development?
+
+      bundle_name = ReactOnRails.configuration.rsc_bundle_js_file
+      @rsc_bundle_path = bundle_js_file_path(bundle_name)
+    end
+
+    def self.react_client_manifest_file_path
+      return @react_client_manifest_path if @react_client_manifest_path && !Rails.env.development?
+
+      file_name = ReactOnRails.configuration.react_client_manifest_file
+      @react_client_manifest_path = ReactOnRails::PackerUtils.asset_uri_from_packer(file_name)
+    end
+
+    # React Server Manifest is generated by the server bundle.
+    # So, it will never be served from the dev server.
+    def self.react_server_client_manifest_file_path
+      return @react_server_manifest_path if @react_server_manifest_path && !Rails.env.development?
+
+      asset_name = ReactOnRails.configuration.react_server_client_manifest_file
+      if asset_name.nil?
+        raise ReactOnRails::Error,
+              "react_server_client_manifest_file is nil, ensure it is set in your configuration"
       end
+
+      @react_server_manifest_path = bundle_js_file_path(asset_name)
     end
 
     def self.running_on_windows?
@@ -133,26 +199,21 @@ module ReactOnRails
     end
 
     def self.source_path
-      if ReactOnRails::PackerUtils.using_packer?
-        ReactOnRails::PackerUtils.packer_source_path
-      else
-        ReactOnRails.configuration.node_modules_location
-      end
+      ReactOnRails::PackerUtils.packer_source_path
     end
 
     def self.using_packer_source_path_is_not_defined_and_custom_node_modules?
-      return false unless ReactOnRails::PackerUtils.using_packer?
-
       !ReactOnRails::PackerUtils.packer_source_path_explicit? &&
         ReactOnRails.configuration.node_modules_location.present?
     end
 
+    def self.public_bundles_full_path
+      ReactOnRails::PackerUtils.packer_public_output_path
+    end
+
+    # DEPRECATED: Use public_bundles_full_path for clarity about public vs private bundle paths
     def self.generated_assets_full_path
-      if ReactOnRails::PackerUtils.using_packer?
-        ReactOnRails::PackerUtils.packer_public_output_path
-      else
-        File.expand_path(ReactOnRails.configuration.generated_assets_dir)
-      end
+      public_bundles_full_path
     end
 
     def self.gem_available?(name)
@@ -185,6 +246,30 @@ module ReactOnRails
                                     end
     end
 
+    def self.react_on_rails_pro_licence_valid?
+      return @react_on_rails_pro_licence_valid if defined?(@react_on_rails_pro_licence_valid)
+
+      @react_on_rails_pro_licence_valid = begin
+        return false unless react_on_rails_pro?
+
+        # Maintain compatibility with legacy versions of React on Rails Pro:
+        # Earlier releases did not require license validation, as they were distributed as private gems.
+        # This check ensures that the method works correctly regardless of the installed version.
+        return true unless ReactOnRailsPro::Utils.respond_to?(:licence_valid?)
+
+        ReactOnRailsPro::Utils.licence_valid?
+      end
+    end
+
+    def self.rsc_support_enabled?
+      return false unless react_on_rails_pro?
+
+      return @rsc_support_enabled if defined?(@rsc_support_enabled)
+
+      rorp_config = ReactOnRailsPro.configuration
+      @rsc_support_enabled = rorp_config.respond_to?(:enable_rsc_support) && rorp_config.enable_rsc_support
+    end
+
     def self.full_text_errors_enabled?
       ENV["FULL_TEXT_ERRORS"] == "true"
     end
@@ -226,5 +311,16 @@ module ReactOnRails
 
       puts "Prepended\n#{text_to_prepend}to #{file}."
     end
+
+    def self.default_troubleshooting_section
+      <<~DEFAULT
+        📞 Get Help & Support:
+           • 🚀 Professional Support: react_on_rails@shakacode.com (fastest resolution)
+           • 💬 React + Rails Slack: https://invite.reactrails.com
+           • 🆓 GitHub Issues: https://github.com/shakacode/react_on_rails/issues
+           • 📖 Discussions: https://github.com/shakacode/react_on_rails/discussions
+      DEFAULT
+    end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/react_on_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReactOnRails
-  VERSION = "14.2.1"
+  VERSION = "16.1.1"
 end

data/lib/react_on_rails/version_checker.rb

@@ -6,7 +6,8 @@ module ReactOnRails
   class VersionChecker
     attr_reader :node_package_version
 
-    MAJOR_MINOR_PATCH_VERSION_REGEX = /(\d+)\.(\d+)\.(\d+)/
+    # Semver uses - to separate pre-release, but RubyGems use .
+    VERSION_PARTS_REGEX = /(\d+)\.(\d+)\.(\d+)(?:[-.]([0-9A-Za-z.-]+))?/
 
     def self.build
       new(NodePackageVersion.build)
@@ -23,13 +24,7 @@ module ReactOnRails
       return if node_package_version.raw.nil? || node_package_version.local_path_or_url?
       return log_node_semver_version_warning if node_package_version.semver_wildcard?
 
-      node_major_minor_patch = node_package_version.major_minor_patch
-      gem_major_minor_patch = gem_major_minor_patch_version
-      versions_match = node_major_minor_patch[0] == gem_major_minor_patch[0] &&
-                       node_major_minor_patch[1] == gem_major_minor_patch[1] &&
-                       node_major_minor_patch[2] == gem_major_minor_patch[2]
-
-      log_differing_versions_warning unless versions_match
+      log_differing_versions_warning unless node_package_version.parts == gem_version_parts
     end
 
     private
@@ -39,20 +34,20 @@ module ReactOnRails
          Detected: #{node_package_version.raw}
               gem: #{gem_version}
          Ensure the installed version of the gem is the same as the version of
-         your installed node package. Do not use >= or ~> in your Gemfile for react_on_rails.
-         Do not use ^ or ~ in your package.json for react-on-rails.
+         your installed Node package. Do not use >= or ~> in your Gemfile for react_on_rails.
+         Do not use ^, ~, or other non-exact versions in your package.json for react-on-rails.
          Run `yarn add react-on-rails --exact` in the directory containing folder node_modules.
       MSG
     end
 
     def log_differing_versions_warning
-      msg = "**WARNING** ReactOnRails: ReactOnRails gem and node package versions do not match\n#{common_error_msg}"
+      msg = "**WARNING** ReactOnRails: ReactOnRails gem and Node package versions do not match\n#{common_error_msg}"
       Rails.logger.warn(msg)
     end
 
     def log_node_semver_version_warning
-      msg = "**WARNING** ReactOnRails: Your node package version for react-on-rails contains a " \
-            "^ or ~\n#{common_error_msg}"
+      msg = "**WARNING** ReactOnRails: Your Node package version for react-on-rails is not an exact version\n" \
+            "#{common_error_msg}"
       Rails.logger.warn(msg)
     end
 
@@ -60,9 +55,8 @@ module ReactOnRails
       ReactOnRails::VERSION
     end
 
-    def gem_major_minor_patch_version
-      match = gem_version.match(MAJOR_MINOR_PATCH_VERSION_REGEX)
-      [match[1], match[2], match[3]]
+    def gem_version_parts
+      gem_version.match(VERSION_PARTS_REGEX)&.captures&.compact
     end
 
     class NodePackageVersion
@@ -100,7 +94,7 @@ module ReactOnRails
         # See https://docs.npmjs.com/cli/v10/configuring-npm/package-json#dependencies
         # We want to disallow all expressions other than exact versions
         # and the ones allowed by local_path_or_url?
-        raw.blank? || raw.match(/[~^><|*-]/).present?
+        raw.blank? || raw.start_with?(/[~^><*]/) || raw.include?(" - ") || raw.include?(" || ")
       end
 
       def local_path_or_url?
@@ -110,15 +104,15 @@ module ReactOnRails
         !raw.nil? && raw.include?("/") && !raw.start_with?("npm:")
       end
 
-      def major_minor_patch
+      def parts
         return if local_path_or_url?
 
-        match = raw.match(MAJOR_MINOR_PATCH_VERSION_REGEX)
+        match = raw.match(VERSION_PARTS_REGEX)
         unless match
           raise ReactOnRails::Error, "Cannot parse version number '#{raw}' (only exact versions are supported)"
         end
 
-        [match[1], match[2], match[3]]
+        match.captures.compact
       end
 
       private

data/lib/react_on_rails/version_syntax_converter.rb

@@ -5,7 +5,7 @@ require_relative "version"
 module ReactOnRails
   class VersionSyntaxConverter
     def rubygem_to_npm(rubygem_version = ReactOnRails::VERSION)
-      regex_match = rubygem_version.match(/(\d+\.\d+\.\d+)[.\-]?(.+)?/)
+      regex_match = rubygem_version.match(/(\d+\.\d+\.\d+)[.-]?(.+)?/)
       return "#{regex_match[1]}-#{regex_match[2]}" if regex_match[2]
 
       regex_match[1].to_s

data/lib/react_on_rails.rb

@@ -26,3 +26,4 @@ require "react_on_rails/test_helper/ensure_assets_compiled"
 require "react_on_rails/locales/base"
 require "react_on_rails/locales/to_js"
 require "react_on_rails/locales/to_json"
+require "react_on_rails/dev"

data/lib/tasks/assets.rake

@@ -26,7 +26,7 @@ namespace :react_on_rails do
       else
         # Left in this warning message in case this rake task is run directly
         msg = <<~MSG
-          React on Rails is aborting webpack compilation from task react_on_rails:assets:webpack
+          React on Rails is aborting Webpack compilation from task react_on_rails:assets:webpack
           because you do not have the `config.build_production_command` defined.
         MSG
         puts Rainbow(msg).red

data/lib/tasks/doctor.rake

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../react_on_rails"
+require_relative "../react_on_rails/doctor"
+
+begin
+  require "rainbow"
+rescue LoadError
+  # Fallback if Rainbow is not available
+  class Rainbow
+    def self.method_missing(_method, text)
+      SimpleColorWrapper.new(text)
+    end
+
+    def self.respond_to_missing?(_method, _include_private = false)
+      true
+    end
+  end
+
+  class SimpleColorWrapper
+    def initialize(text)
+      @text = text
+    end
+
+    def method_missing(_method, *_args)
+      self
+    end
+
+    def respond_to_missing?(_method, _include_private = false)
+      true
+    end
+
+    def to_s
+      @text
+    end
+  end
+end
+
+namespace :react_on_rails do
+  desc "Diagnose React on Rails setup and configuration"
+  task :doctor do
+    verbose = ENV["VERBOSE"] == "true"
+    fix = ENV["FIX"] == "true"
+
+    doctor = ReactOnRails::Doctor.new(verbose: verbose, fix: fix)
+    doctor.run_diagnosis
+  end
+end

data/lib/tasks/generate_packs.rake

@@ -1,11 +1,168 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/BlockLength
 namespace :react_on_rails do
   desc <<~DESC
     If there is a file inside any directory matching config.components_subdirectory, this command generates corresponding packs.
+
+    This task will:
+    - Clean out existing generated directories (javascript/generated and javascript/packs/generated)
+    - List all files being deleted for transparency
+    - Generate new pack files for discovered React components
+    - Skip generation if files are already up to date
+
+    Generated directories:
+    - app/javascript/packs/generated/ (client pack files)
+    - app/javascript/generated/ (server bundle files)
   DESC
 
   task generate_packs: :environment do
-    ReactOnRails::PacksGenerator.instance.generate_packs_if_stale
+    puts Rainbow("🚀 Starting React on Rails pack generation...").bold
+    puts Rainbow("📁 Auto-load bundle: #{ReactOnRails.configuration.auto_load_bundle}").cyan
+    puts Rainbow("📂 Components subdirectory: #{ReactOnRails.configuration.components_subdirectory}").cyan
+    puts ""
+
+    begin
+      start_time = Time.now
+      ReactOnRails::PacksGenerator.instance.generate_packs_if_stale
+      end_time = Time.now
+
+      puts ""
+      puts Rainbow("✨ Pack generation completed in #{((end_time - start_time) * 1000).round(1)}ms").green
+    rescue ReactOnRails::Error => e
+      handle_react_on_rails_error(e)
+      exit 1
+    rescue StandardError => e
+      handle_standard_error(e)
+      exit 1
+    end
+  end
+
+  private
+
+  # rubocop:disable Metrics/AbcSize
+  def handle_react_on_rails_error(error)
+    puts ""
+    puts Rainbow("❌ REACT ON RAILS ERROR").red.bold
+    puts Rainbow("=" * 80).red
+    puts Rainbow("🚨 Pack generation failed with the following error:").red
+    puts ""
+    puts Rainbow("📋 ERROR DETAILS:").yellow
+    puts Rainbow("   Type: #{error.class.name}").white
+    puts Rainbow("   Message: #{error.message}").white
+    puts ""
+
+    highlight_main_error(error)
+    show_common_solutions(error)
+    show_debugging_steps
+    show_documentation_links
+  end
+  # rubocop:enable Metrics/AbcSize
+
+  def highlight_main_error(error)
+    return unless error.message.include?("**ERROR**")
+
+    error_lines = error.message.split("\n")
+    error_lines.each do |line|
+      next unless line.include?("**ERROR**")
+
+      puts Rainbow("🔥 MAIN ISSUE:").red.bold
+      puts Rainbow("   #{line.gsub('**ERROR**', '').strip}").yellow
+    end
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def show_common_solutions(error)
+    puts ""
+    puts Rainbow("💡 COMMON SOLUTIONS:").green.bold
+
+    case error.message
+    when /client specific definition.*overrides the common definition/
+      puts Rainbow("   • You have both common and client/server specific component files").white
+      puts Rainbow("   • Delete the common component file (e.g., Component.jsx)").white
+      puts Rainbow("   • Keep only the client/server specific files " \
+                   "(Component.client.jsx, Component.server.jsx)").white
+      puts Rainbow("   • See: https://www.shakacode.com/react-on-rails/docs/guides/" \
+                   "auto-bundling-file-system-based-automated-bundle-generation.md").cyan
+
+    when /Cannot find component/
+      puts Rainbow("   • Check that your component file exists in the expected location").white
+      puts Rainbow("   • Verify the component is exported as default export").white
+      puts Rainbow("   • Ensure the file extension is .jsx or .js").white
+
+    when /CSS module.*not found/
+      puts Rainbow("   • Check that the CSS module file exists").white
+      puts Rainbow("   • Verify the import path is correct").white
+      puts Rainbow("   • Ensure all CSS classes referenced in the component exist").white
+
+    else
+      puts Rainbow("   • Check component file structure and naming").white
+      puts Rainbow("   • Verify all imports and exports are correct").white
+      puts Rainbow("   • Run with --trace for more detailed error information").white
+    end
+  end
+  # rubocop:enable Metrics/AbcSize
+
+  def show_debugging_steps
+    puts ""
+    puts Rainbow("🔧 DEBUGGING STEPS:").blue.bold
+    components_path = "app/javascript/src/**/#{ReactOnRails.configuration.components_subdirectory}/"
+    puts Rainbow("   1. Check component files in: #{components_path}").white
+    puts Rainbow("   2. Verify component exports: export default ComponentName").white
+    puts Rainbow("   3. Check for conflicting common/client/server files").white
+    puts Rainbow("   4. Run: rake react_on_rails:generate_packs --trace").white
+    puts Rainbow("   5. Check Rails logs for additional details").white
+  end
+
+  def show_documentation_links
+    puts ""
+    puts Rainbow("📚 DOCUMENTATION:").magenta.bold
+    puts Rainbow("   • File-system based components: https://www.shakacode.com/react-on-rails/docs/" \
+                 "guides/auto-bundling-file-system-based-automated-bundle-generation.md").cyan
+    puts Rainbow("   • Component registration: https://www.shakacode.com/react-on-rails/docs/").cyan
+    puts Rainbow("=" * 80).red
+  end
+
+  def show_help_and_support
+    puts ""
+    troubleshooting_content = ReactOnRails::Utils.default_troubleshooting_section
+    # Display the troubleshooting content with color formatting
+    troubleshooting_content.split("\n").each do |line|
+      case line
+      when /^📞/
+        puts Rainbow(line).magenta.bold
+      when /^\s*•\s*🚀/
+        puts Rainbow(line).yellow
+      when /^\s*•/
+        puts Rainbow(line).cyan
+      else
+        puts Rainbow(line).white unless line.strip.empty?
+      end
+    end
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def handle_standard_error(error)
+    puts ""
+    puts Rainbow("❌ UNEXPECTED ERROR").red.bold
+    puts Rainbow("=" * 80).red
+    puts Rainbow("🚨 An unexpected error occurred during pack generation:").red
+    puts ""
+    puts Rainbow("📋 ERROR DETAILS:").yellow
+    puts Rainbow("   Type: #{error.class.name}").white
+    puts Rainbow("   Message: #{error.message}").white
+    puts Rainbow("   Backtrace:").white
+    error.backtrace.first(10).each { |line| puts Rainbow("     #{line}").white }
+    puts Rainbow("     ... (run with --trace for full backtrace)").white
+    puts ""
+    puts Rainbow("🔧 DEBUGGING STEPS:").blue.bold
+    puts Rainbow("   1. Run: rake react_on_rails:generate_packs --trace").white
+    puts Rainbow("   2. Check Rails logs: tail -f log/development.log").white
+    puts Rainbow("   3. Verify all dependencies are installed: bundle install && npm install").white
+    puts Rainbow("   4. Clear cache: rm -rf tmp/cache").white
+    show_help_and_support
+    puts Rainbow("=" * 80).red
   end
+  # rubocop:enable Metrics/AbcSize
 end
+# rubocop:enable Metrics/BlockLength

data/react_on_rails.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
   s.add_dependency "execjs", "~> 2.5"
   s.add_dependency "rails", ">= 5.2"
   s.add_dependency "rainbow", "~> 3.0"
+  s.add_dependency "shakapacker", ">= 6.0"
 
   s.add_development_dependency "gem-release"
   s.post_install_message = '

data/tsconfig.eslint.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true
+  }
+}

data/tsconfig.json

@@ -6,12 +6,14 @@
     // needed for Jest tests even though we don't use .tsx
     "jsx": "react-jsx",
     "lib": ["dom", "es2020"],
-    "module": "node16",
     "noImplicitAny": true,
     "outDir": "node_package/lib",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
     "strict": true,
     "incremental": true,
-    "target": "es2020"
+    "target": "es2020",
+    "typeRoots": ["./node_modules/@types", "./node_package/types"]
   },
-  "include": ["node_package/src/**/*"]
+  "include": ["node_package/src/**/*", "node_package/types/**/*"]
 }