proscenium 0.18.0-arm64-darwin → 0.19.0-arm64-darwin

data/lib/proscenium/ext/proscenium.h

@@ -24,6 +24,7 @@ typedef struct { const char *p; ptrdiff_t n; } _GoString_;
 struct Result {
 	int success;
 	char* response;
+	char* contentHash;
 };
 
 #line 1 "cgo-generated-wrapper"
@@ -82,49 +83,21 @@ typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
 extern "C" {
 #endif
 
+extern void reset_config();
 
-// Build the given `path` in the `root`.
+// Build the given `path` using the `config`.
 //
-//	BuildOptions
-//	- path - The path to build relative to `root`.
-//	- baseUrl - base URL of the Rails app. eg. https://example.com
-//	- importMap - Path to the import map relative to `root`.
-//	- envVars - JSON string of environment variables.
-//	Config:
-//	- root - The working directory.
-//	- env - The environment (1 = development, 2 = test, 3 = production)
-//	- codeSpitting?
-//	- debug?
+// - path - The path to build relative to `root`.
+// - config
 //
-extern struct Result build_to_string(char* filepath, char* baseUrl, char* importMap, char* envVars, char* appRoot, char* gemPath, unsigned int env, GoUint8 codeSplitting, char* engines, GoUint8 debug);
-
-// Build the given `path` in the `root`.
-//
-//	BuildOptions
-//	- path - The path to build relative to `root`. Multiple paths can be given by separating them
-//	  with a semi-colon.
-//	- baseUrl - base URL of the Rails app. eg. https://example.com
-//	- importMap - Path to the import map relative to `root`.
-//	- envVars - JSON string of environment variables.
-//	Config:
-//	- root - The working directory.
-//	- env - The environment (1 = development, 2 = test, 3 = production)
-//	- codeSpitting?
-//	- debug?
-//
-extern struct Result build_to_path(char* filepath, char* baseUrl, char* importMap, char* envVars, char* appRoot, char* gemPath, unsigned int env, GoUint8 codeSplitting, char* engines, GoUint8 debug);
+extern struct Result build_to_string(char* filePath, char* configJson);
 
 // Resolve the given `path` relative to the `root`.
 //
-//	ResolveOptions
-//	- path - The path to build relative to `root`.
-//	- importMap - Path to the import map relative to `root`.
-//	Config
-//	- root - The working directory.
-//	- env - The environment (1 = development, 2 = test, 3 = production)
-//	- debug?
+// - path - The path to build relative to `root`.
+// - config
 //
-extern struct Result resolve(char* path, char* importMap, char* appRoot, char* gemPath, unsigned int env, GoUint8 debug);
+extern struct Result resolve(char* filePath, char* configJson);
 
 #ifdef __cplusplus
 }

data/lib/proscenium/helper.rb

@@ -16,15 +16,13 @@ module Proscenium
     # those asset paths all begin with a slash, which the Rails asset helpers do not pass through to
     # here.
     #
-    # If the given `path` is a bare path (does not start with `/` or `./` or `../`), then we use
+    # If the given `path` is a bare path (does not start with `./` or `../`), then we use
     # Rails default conventions, and serve CSS from /app/assets/stylesheets and JS from
     # /app/javascript.
     def compute_asset_path(path, options = {})
       if %i[javascript stylesheet].include?(options[:type])
-        path.prepend DEFAULT_RAILS_ASSET_PATHS[options[:type]] unless path.start_with?('./', '../')
-
-        result = Proscenium::Builder.build_to_path(path, base_url: request.base_url)
-        return result.split('::').last.delete_prefix 'public'
+        path.prepend DEFAULT_RAILS_ASSET_PATHS[options[:type]] if !path.start_with?('./', '../')
+        return path
       end
 
       super
@@ -42,18 +40,6 @@ module Proscenium
                             .map { |name, _| name }.join(' ')
     end
 
-    # @param name [String,Symbol,Array<String,Symbol>]
-    # @param path [Pathname] the path to the CSS file to use for the transformation.
-    # @return [String] the transformed CSS module names concatenated as a string.
-    def class_names(*names, path: nil)
-      names = names.flatten.compact
-
-      return if names.empty?
-
-      path ||= Pathname.new(@lookup_context.find(@virtual_path).identifier).sub_ext('')
-      CssModule::Transformer.new(path).class_names(*names).map { |name, _| name }.join(' ')
-    end
-
     def include_assets
       include_stylesheets + include_javascripts
     end
@@ -61,16 +47,12 @@ module Proscenium
     def include_stylesheets
       SideLoad::CSS_COMMENT.html_safe
     end
-    alias side_load_stylesheets include_stylesheets
-    deprecate side_load_stylesheets: 'Use `include_stylesheets` instead', deprecator: Deprecator.new
 
     # Includes all javascripts that have been imported and side loaded.
     #
     # @return [String] the HTML tags for the javascripts.
     def include_javascripts
-      (SideLoad::LAZY_COMMENT + SideLoad::JS_COMMENT).html_safe
+      SideLoad::JS_COMMENT.html_safe
     end
-    alias side_load_javascripts include_javascripts
-    deprecate side_load_javascripts: 'Use `include_javascripts` instead', deprecator: Deprecator.new
   end
 end

data/lib/proscenium/importer.rb

@@ -23,19 +23,24 @@ module Proscenium
       #
       # @param filepath [String] Absolute URL path (relative to Rails root) of the file to import.
       #   Should be the actual asset file, eg. app.css, some/component.js.
-      # @param resolve [String] description of the file to resolve and import.
-      # @return [String] the digest of the imported file path if a css module (*.module.css).
-      def import(filepath = nil, resolve: nil, **)
+      # @return [String|nil] the digest of the imported file path if a css module (*.module.css).
+      def import(filepath = nil, sideloaded: false, **)
         self.imported ||= {}
 
-        filepath = Resolver.resolve(resolve) if !filepath && resolve
+        filepath = "/node_modules/#{filepath}" if filepath.start_with?('@rubygems/')
         css_module = filepath.end_with?('.module.css')
 
         unless self.imported.key?(filepath)
-          # ActiveSupport::Notifications.instrument('sideload.proscenium', identifier: value)
-
-          self.imported[filepath] = { ** }
-          self.imported[filepath][:digest] = Utils.digest(filepath) if css_module
+          if sideloaded
+            ActiveSupport::Notifications.instrument 'sideload.proscenium', identifier: filepath,
+                                                                           sideloaded: do
+              self.imported[filepath] = { ** }
+              self.imported[filepath][:digest] = Utils.digest(filepath) if css_module
+            end
+          else
+            self.imported[filepath] = { ** }
+            self.imported[filepath][:digest] = Utils.digest(filepath) if css_module
+          end
         end
 
         css_module ? self.imported[filepath][:digest] : nil
@@ -60,6 +65,7 @@ module Proscenium
       # `.tsx` extension is matched first.
       #
       # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
+      # @param options [Hash] Options to pass to `import`.
       def sideload(filepath, **options)
         return if !Proscenium.config.side_load || (options[:js] == false && options[:css] == false)
 
@@ -67,30 +73,42 @@ module Proscenium
         sideload_css(filepath, **options) unless options[:css] == false
       end
 
-      def sideload_js(filepath, **options)
-        return unless Proscenium.config.side_load
+      def sideload_js(filepath, **)
+        _sideload(filepath, JS_EXTENSIONS, **)
+      end
 
-        filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
-        filepath = filepath.sub_ext('')
+      def sideload_css(filepath, **)
+        _sideload(filepath, ['.css'], **)
+      end
 
-        JS_EXTENSIONS.find do |x|
-          if (fp = filepath.sub_ext(x)).exist?
-            import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
-          end
-        end
+      def sideload_css_module(filepath, **)
+        _sideload(filepath, ['.module.css'], **)
       end
 
-      def sideload_css(filepath, **options)
+      # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
+      # @param extensions [Array<String>] Supported file extensions to sideload.
+      # @param options [Hash] Options to pass to `import`.
+      # @return [Array<String>] The imported file paths.
+      # @raise [ArgumentError] if `filepath` is not an absolute file system path.
+      private def _sideload(filepath, extensions, **options) # rubocop:disable Style/AccessModifierDeclarations
         return unless Proscenium.config.side_load
 
-        filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
+        if !filepath.is_a?(Pathname) || !filepath.absolute?
+          raise ArgumentError, "`filepath` (#{filepath}) must be a `Pathname`, and an absolute path"
+        end
+
+        # Ensures extensions with more than one dot are handled correctly.
         filepath = filepath.sub_ext('')
 
-        CSS_EXTENSIONS.find do |x|
+        sideloaded = []
+
+        extensions.find do |x|
           if (fp = filepath.sub_ext(x)).exist?
-            import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
+            sideloaded << import(Resolver.resolve(fp.to_s), sideloaded: filepath, **options)
           end
         end
+
+        sideloaded
       end
 
       def each_stylesheet(delete: false)

data/lib/proscenium/log_subscriber.rb

@@ -5,33 +5,34 @@ require 'active_support/log_subscriber'
 module Proscenium
   class LogSubscriber < ActiveSupport::LogSubscriber
     def sideload(event)
+      path = event.payload[:identifier]
+      sideloaded = event.payload[:sideloaded]
+      sideloaded = sideloaded.relative_path_from(Rails.root) if sideloaded.is_a?(Pathname)
+
       info do
-        "  [Proscenium] Side loaded #{event.payload[:identifier]}"
+        msg = "  #{color('[Proscenium]', nil, bold: true)} Sideloading #{path}"
+        sideloaded.is_a?(Pathname) ? msg << " from #{sideloaded}" : msg
       end
     end
 
-    def build_to_path(event)
+    def build(event)
       path = event.payload[:identifier]
-      cached = event.payload[:cached] ? ' | Cached!' : ''
       path = CGI.unescape(path) if path.start_with?(/https?%3A%2F%2F/)
 
       info do
-        message = "  #{color('[Proscenium]', nil, bold: true)} Building (to path) #{path}"
-        message << " (Duration: #{event.duration.round(1)}ms | " \
-                   "Allocations: #{event.allocations}#{cached})"
+        message = "#{color('[Proscenium]', nil, bold: true)} Building /#{path}"
+        message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
       end
     end
 
-    def build_to_string(event)
+    def resolve(event)
       path = event.payload[:identifier]
       path = CGI.unescape(path) if path.start_with?(/https?%3A%2F%2F/)
 
       info do
-        message = "  #{color('[Proscenium]', nil, bold: true)} Building #{path}"
+        message = "  #{color('[Proscenium]', nil, bold: true)} Resolving #{path}"
         message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
       end
     end
   end
 end
-
-Proscenium::LogSubscriber.attach_to :proscenium

data/lib/proscenium/middleware/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'oj'
-
 module Proscenium
   class Middleware
     class Base
@@ -79,18 +77,25 @@ module Proscenium
         end
       end
 
-      def render_response(content)
+      def render_response(result)
+        content = result[:response]
+
         response = Rack::Response.new
-        response.write content
-        response.content_type = content_type
         response['X-Proscenium-Middleware'] = name
         response.set_header 'SourceMap', "#{@request.path_info}.map"
+        response.content_type = content_type
+        response.etag = result[:content_hash]
 
         if Proscenium.config.cache_query_string && Proscenium.config.cache_max_age
           response.cache! Proscenium.config.cache_max_age
         end
 
-        yield response if block_given?
+        if @request.fresh?(response)
+          response.status = 304
+          response.body = []
+        else
+          response.write content
+        end
 
         response.finish
       end

data/lib/proscenium/middleware/esbuild.rb

@@ -6,22 +6,21 @@ module Proscenium
       class CompileError < Base::CompileError
         def initialize(args)
           detail = args[:detail]
-          detail = ActiveSupport::HashWithIndifferentAccess.new(Oj.load(detail, mode: :strict))
+          detail = JSON.parse(detail, mode: :strict)
 
-          args[:detail] = if detail[:location]
-                            "#{detail[:text]} in #{detail[:location][:file]}:" +
-                              detail[:location][:line].to_s
-                          else
-                            detail[:text]
-                          end
+          args['detail'] = if detail['location']
+                             "#{detail['text']} in #{detail['location']['file']}:" +
+                               detail['location']['line'].to_s
+                           else
+                             detail['text']
+                           end
 
           super
         end
       end
 
       def attempt
-        render_response Builder.build_to_string(path_to_build, root: Rails.root.to_s,
-                                                               base_url: @request.base_url)
+        render_response Builder.build_to_string(path_to_build)
       rescue Builder::CompileError => e
         raise self.class::CompileError, { file: @request.fullpath, detail: e.message }, caller
       end

data/lib/proscenium/middleware/ruby_gems.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class RubyGems < Esbuild
+      def real_path
+        @real_path ||= Pathname.new(gem_request_path.delete_prefix("#{gem_name}/")).to_s
+      end
+
+      def root_for_readable
+        BundledGems.pathname_for!(gem_name)
+      end
+
+      def gem_name
+        @gem_name ||= gem_request_path.split('/').first
+      end
+
+      def gem_request_path
+        @gem_request_path ||= @request.path.delete_prefix('/node_modules/@rubygems/')
+      end
+    end
+  end
+end

data/lib/proscenium/middleware.rb

@@ -9,8 +9,7 @@ module Proscenium
 
     autoload :Base
     autoload :Esbuild
-    autoload :Engines
-    autoload :Runtime
+    autoload :RubyGems
 
     def initialize(app)
       @app = app
@@ -21,10 +20,25 @@ module Proscenium
     end
 
     def call(env)
-      request = Rack::Request.new(env)
+      request = ActionDispatch::Request.new(env)
 
       return @app.call(env) if !request.get? && !request.head?
-      return @chunk_handler.attempt(request.env) if request.path.match?(%r{^/_asset_chunks/})
+
+      if request.path.match?(%r{^/_asset_chunks/})
+        response = Rack::Response[*@chunk_handler.attempt(request.env)]
+        response.etag = request.path.match(/-\$([a-z0-9]+)\$/i)[1]
+
+        if Proscenium.config.cache_query_string && Proscenium.config.cache_max_age
+          response.cache! Proscenium.config.cache_max_age
+        end
+
+        if request.fresh?(response)
+          response.status = 304
+          response.body = []
+        end
+
+        return response.finish
+      end
 
       attempt(request) || @app.call(env)
     end
@@ -34,41 +48,29 @@ module Proscenium
     def attempt(request)
       return unless (type = find_type(request))
 
-      # file_handler.attempt(request.env) || type.attempt(request)
-
       type.attempt request
     end
 
     def find_type(request)
-      return Runtime if request.path.match?(%r{^/@proscenium/})
-      return Esbuild if Pathname.new(request.path).fnmatch?(app_path_glob, File::FNM_EXTGLOB)
-
       pathname = Pathname.new(request.path)
-      Engines if pathname.fnmatch?(ui_path_glob, File::FNM_EXTGLOB) ||
-                 pathname.fnmatch?(engines_path_glob, File::FNM_EXTGLOB)
+
+      if pathname.fnmatch?(gems_path_glob, File::FNM_EXTGLOB)
+        RubyGems
+      elsif pathname.fnmatch?(app_path_glob, File::FNM_EXTGLOB)
+        Esbuild
+      end
     end
 
     def app_path_glob
       "/{#{Proscenium::ALLOWED_DIRECTORIES}}/**.{#{file_extensions}}"
     end
 
-    def engines_path_glob
-      names = Proscenium.config.engines.map(&:engine_name)
-      "/{#{names.join(',')}}/{#{Proscenium::ALLOWED_DIRECTORIES}}/**.{#{file_extensions}}"
-    end
-
-    def ui_path_glob
-      "/proscenium/ui/**.{#{file_extensions}}"
+    def gems_path_glob
+      "/node_modules/@rubygems/**.{#{file_extensions}}"
     end
 
     def file_extensions
       @file_extensions ||= FILE_EXTENSIONS.join(',')
     end
-
-    # TODO: handle precompiled assets
-    # def file_handler
-    #   ::ActionDispatch::FileHandler.new Rails.public_path.join('assets').to_s,
-    #                                     headers: { 'X-Proscenium-Middleware' => 'precompiled' }
-    # end
   end
 end

data/lib/proscenium/monkey.rb

@@ -1,24 +1,16 @@
 # frozen_string_literal: true
 
 module Proscenium
-  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   module Monkey
     module TemplateRenderer
       private
 
-      def render_template(view, template, layout_name, locals) # rubocop:disable Metrics/*
+      def render_template(view, template, layout_name, locals)
         result = super
         return result if !view.controller || !Proscenium.config.side_load
 
-        renderable = template.instance_variable_get(:@renderable)
-
-        to_sideload = if Object.const_defined?(:ViewComponent) &&
-                         template.is_a?(ActionView::Template::Renderable) &&
-                         renderable.class < ::ViewComponent::Base &&
-                         renderable.class.format == :html
-                        renderable
-                      elsif template.respond_to?(:virtual_path) &&
-                            template.respond_to?(:type) && template.type == :html
+        to_sideload = if template.respond_to?(:virtual_path) &&
+                         template.respond_to?(:type) && template.type == :html
                         template
                       end
         if to_sideload
@@ -48,7 +40,7 @@ module Proscenium
           options[k] = controller.instance_eval(&options[k]) if options[k].is_a?(Proc)
         end
 
-        Importer.sideload "app/views/#{tpl.virtual_path}", **options
+        Importer.sideload Rails.root.join("app/views/#{tpl.virtual_path}"), **options
       end
     end
 
@@ -87,9 +79,8 @@ module Proscenium
           options[k] = controller.instance_eval(&options[k]) if options[k].is_a?(Proc)
         end
 
-        Importer.sideload "app/views/#{tpl.virtual_path}", **options
+        Importer.sideload Rails.root.join("app/views/#{tpl.virtual_path}"), **options
       end
     end
   end
-  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 end

data/lib/proscenium/railtie.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rails'
-require 'proscenium/log_subscriber'
 
 ENV['RAILS_ENV'] = Rails.env
 
@@ -11,14 +10,11 @@ module Proscenium
 
     config.proscenium = ActiveSupport::OrderedOptions.new
     config.proscenium.debug = false
+    config.proscenium.logging = true
+    config.proscenium.bundle = true
     config.proscenium.side_load = true
     config.proscenium.code_splitting = true
-
-    # Cache asset paths when building to path. Enabled by default in production.
-    # @see Proscenium::Builder#build_to_path
-    config.proscenium.cache = ActiveSupport::Cache::MemoryStore.new if Rails.env.production?
-
-    # TODO: implement!
+    config.proscenium.ensure_loaded = :raise
     config.proscenium.cache_query_string = Rails.env.production? && ENV.fetch('REVISION', nil)
     config.proscenium.cache_max_age = 2_592_000 # 30 days
 
@@ -27,45 +23,28 @@ module Proscenium
     # defined means a faster build, as esbuild will have less to do.
     config.proscenium.env_vars = Set.new
 
-    # Rails engines to expose and allow Proscenium to serve their assets.
-    #
-    # A Rails engine that has assets, can add Proscenium as a gem dependency, and then add itself
-    # to this list. Proscenium will then serve the engine's assets at the URL path beginning with
-    # the engine name.
-    #
-    # Example:
-    #   class Gem1::Engine < ::Rails::Engine
-    #     config.proscenium.engines << self
-    #   end
-    config.proscenium.engines = Set.new
-
     config.action_dispatch.rescue_templates = {
       'Proscenium::Builder::BuildError' => 'build_error'
     }
 
     config.after_initialize do |_app|
-      ActiveSupport.on_load(:action_view) do
-        include Proscenium::Helper
+      if config.proscenium.logging
+        require 'proscenium/log_subscriber'
+        Proscenium::LogSubscriber.attach_to :proscenium
       end
-    end
 
-    initializer 'proscenium.ui' do
-      ActiveSupport::Inflector.inflections(:en) do |inflect|
-        inflect.acronym 'UI'
+      ActiveSupport.on_load(:action_view) do
+        include Proscenium::Helper
       end
     end
 
     initializer 'proscenium.debugging' do
-      if Rails.gem_version >= Gem::Version.new('7.1.0')
-        tpl_path = root.join('lib', 'proscenium', 'templates').to_s
-        ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS << tpl_path
-      end
+      tpl_path = root.join('lib', 'proscenium', 'templates').to_s
+      ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS << tpl_path
     end
 
     initializer 'proscenium.middleware' do |app|
-      app.middleware.insert_after ActionDispatch::Static, Middleware
-      app.middleware.insert_after ActionDispatch::Static, Rack::ETag, 'no-cache'
-      app.middleware.insert_after ActionDispatch::Static, Rack::ConditionalGet
+      app.middleware.insert_after ActionDispatch::Static, Proscenium::Middleware
     end
 
     initializer 'proscenium.sideloading' do
@@ -81,26 +60,5 @@ module Proscenium
         ActionView::PartialRenderer.prepend Monkey::PartialRenderer
       end
     end
-
-    initializer 'proscenium.public_path' do |app|
-      if app.config.public_file_server.enabled
-        headers = app.config.public_file_server.headers || {}
-        index = app.config.public_file_server.index_name || 'index'
-
-        app.middleware.insert_after(ActionDispatch::Static, ActionDispatch::Static,
-                                    root.join('public').to_s, index:, headers:)
-      end
-    end
-  end
-end
-
-if Rails.gem_version < Gem::Version.new('7.1.0')
-  class ActionDispatch::DebugView
-    def initialize(assigns)
-      tpl_path = Proscenium::Railtie.root.join('lib', 'proscenium', 'templates').to_s
-      paths = [RESCUES_TEMPLATE_PATH, tpl_path]
-      lookup_context = ActionView::LookupContext.new(paths)
-      super(lookup_context, assigns, nil)
-    end
   end
 end

data/lib/proscenium/{libs/react-manager → react-manager}/index.jsx

@@ -1,15 +1,5 @@
-window.Proscenium = window.Proscenium || { lazyScripts: {} };
 const pathAttribute = "data-proscenium-component-path";
 
-// Find lazyscripts JSON already in the DOM.
-const element = document.querySelector("#prosceniumLazyScripts");
-if (element) {
-  window.Proscenium.lazyScripts = {
-    ...window.Proscenium.lazyScripts,
-    ...JSON.parse(element.text),
-  };
-}
-
 // Find components already in the DOM.
 const elements = document.querySelectorAll(`[${pathAttribute}]`);
 elements.length > 0 && init(elements);
@@ -17,12 +7,7 @@ elements.length > 0 && init(elements);
 new MutationObserver((mutationsList) => {
   for (const { addedNodes } of mutationsList) {
     for (const ele of addedNodes) {
-      if (ele.tagName === "SCRIPT" && ele.id === "prosceniumLazyScripts") {
-        window.Proscenium.lazyScripts = {
-          ...window.Proscenium.lazyScripts,
-          ...JSON.parse(ele.text),
-        };
-      } else if (ele.matches(`[${pathAttribute}]`)) {
+      if (ele.matches(`[${pathAttribute}]`)) {
         init([ele]);
       }
     }
@@ -81,12 +66,8 @@ function init(elements) {
     // For testing and simulation of slow connections.
     // const sim = new Promise((resolve) => setTimeout(resolve, 5000));
 
-    if (!window.Proscenium.lazyScripts[path]) {
-      throw `[proscenium/react/manager] Cannot load component ${path} (not found in Proscenium.lazyScripts)`;
-    }
-
-    const react = import("@proscenium/react-manager/react");
-    const Component = import(window.Proscenium.lazyScripts[path].outpath);
+    const react = import("@rubygems/proscenium/react-manager/react");
+    const Component = import(path);
 
     const forwardChildren =
       "prosceniumComponentForwardChildren" in element.dataset &&

data/lib/proscenium/react_componentable.rb

@@ -11,7 +11,7 @@ module Proscenium
       # The HTML tag to use as the wrapping element for the component. You can reassign this in your
       # component class to use a different tag:
       #
-      #   class MyComponent < Proscenium::ViewComponent::ReactComponent
+      #   class MyComponent < Proscenium::ReactComponent
       #     self.root_tag = :span
       #   end
       #
@@ -40,13 +40,12 @@ module Proscenium
       class_attribute :loader
 
       # @return [String] the URL path to the component manager.
-      class_attribute :manager, default: '/@proscenium/react-manager/index.jsx'
+      class_attribute :manager, default: '/proscenium/react-manager/index.jsx'
     end
 
     class_methods do
       def sideload(options)
         Importer.import manager, **options, js: { type: 'module' }
-        Importer.sideload source_path, lazy: true, **options
       end
     end