proscenium 0.19.0.beta19-x86_64-linux → 0.19.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46c76525cb575df04643c01e0ea06496fdb9899225a0642a8a67b5db9b989fd7
-  data.tar.gz: 665dc07d4f1fbd163129804c52055a1d1c6a57201364ab6e8a1c3863f403bd22
+  metadata.gz: e686c9d55f815ad70fc17be7ad98bde1bfaf57dd426464a75fda4b3f08fd3d9d
+  data.tar.gz: 362e72b47cdcb0743cff1ab94e3cc413f2b85e605225fbc2706342760958133a
 SHA512:
-  metadata.gz: 6adb9c8b4fabccb7ecd23764baa90020fcac72f733cccbc1291a79135252ea0685221f04426aade84835bd18325c70a8ed87764bb40c0f8eccdccd83a3819daf
-  data.tar.gz: 84e679af253d7f4f9637cfde8472d12eac84a77037fd96b97c71c9dcdbbee15cecf51cea32e2682c4e1f07db8ec99e76b5dc340ac5613eee35507d13f41c85c6
+  metadata.gz: 17a945e83e1e18faff56b408ef10245dec73b7baea589f41fc5125d7febb89f88463c09b2a868889ee8275879961b2e04cf3b9ef6c6632f1612504aa7d4aa2ae
+  data.tar.gz: 889ed2b063887281c9aa1e51c28f5c7aad1bc8f400bf5090e7121b0fc6718c9e4584b9c5d5320a99a8029c4cccd1255fffaefa761f648920d879ea45463c390d

data/README.md

@@ -6,17 +6,17 @@
 >
 > - _the part of a theatre stage in front of the curtain._
 
-**_Proscenium_** treats your frontend and client-side code as first class citizens of your Rails app, and assumes a "fast by default" internet. It bundles and minifies JavaScript (+ JSX), TypeScript (+TSX) and CSS in real time, on demand, and with zero configuration.
+**_Proscenium_** treats your frontend and client-side code as first class citizens of your Rails app, and assumes a "fast by default" internet. It bundles and minifies JavaScript (+JSX), TypeScript (+TSX) and CSS in real time, on demand, and with zero configuration.
 
 **The highlights:**
 
 - Fast, real-time bundling, tree-shaking, code-splitting and minification of Javascript (.js,.jsx), Typescript (.ts,.tsx) and CSS (.css).
 - NO JavaScript runtime needed (eg. Node) - just the browser!
 - NO build step or pre-compilation.
-- NO additional process or server - Just run `rails s`!
+- NO additional process or server - Just run `rails server`!
 - Transforms newer JavaScript and CSS syntax to older syntax for older browsers.
 - Deep integration with Rails.
-- Automatically side-load your layouts, views, and partials.
+- Automatically side-load JS and CSS for your layouts, views, and partials.
 - Import from NPM, URL's, and locally.
 - Server-side import map support.
 - CSS Modules & mixins.
@@ -48,7 +48,6 @@
   - [Typescript Caveats](#typescript-caveats)
 - [JSX](#jsx)
 - [JSON](#json)
-- [Phlex Support](#phlex-support)
 - [Cache Busting](#cache-busting)
 - [rjs is back!](#rjs-is-back)
 - [Resolution](#resolution)
@@ -76,15 +75,15 @@ gem 'proscenium'
 
 Please note that Proscenium is designed solely for use with Rails.
 
-Now if you start your Rails app, you can open any front end code (JS, CSS, etc.). For example, a file at `app/assets/stylesheets/application.css` can be accessed at `https://localhost:3000/app/assets/stylesheets/application.css`, which will be bundled, transformed, and minified [in production] in real time.
+Now if you start your Rails app, you can open any front end code (JS, CSS, etc.). For example, a file at `app/assets/stylesheets/application.css` can be accessed at `https://localhost:3000/app/assets/stylesheets/application.css`, which will be transformed, bundled, and minified [in production] in real time.
 
 ## Client-Side Code Anywhere
 
-Proscenium believes that your frontend code is just as important as your backend code, and is not an afterthought - they should be first class citizens of your Rails app. So instead of having to throw all your JS and CSS into a "app/assets" directory, and then requiring a separate process to compile or bundle, just put them wherever you want within your app, and just run Rails!
+Proscenium believes that your frontend code is just as important as your backend code, and is not an afterthought - they should be first class citizens of your Rails app. So instead of having to throw all your JS and CSS into a "app/assets" directory, and then requiring a separate process to compile or bundle, you can simply put them wherever you want within your app, and just run Rails!
 
 For example, if you have some JS that is required by your `app/views/users/index.html.erb` view, just create a JS file alongside it at `app/views/users/index.js`. Or if you have some CSS that is used by your entire application, put it in `app/views/layouts/application.css` and load it alongside your layout. Maybe you have a few JS utility functions, so put them in `lib/utils.js`.
 
-Simply put your JS(X) and CSS anywhere you want, and they will be served by your Rails app from the location where you placed them.
+Simply put your JS(X) and CSS anywhere you want, and they will be served by your Rails app from the same location where you placed them.
 
 Using the examples above...
 
@@ -96,15 +95,15 @@ Using the examples above...
 
 ## Side Loading
 
-Proscenium is best experienced when your assets are automtically side loaded.
+Proscenium is best experienced when your assets are automatically side loaded.
 
 ### The Problem
 
-With Rails you would typically declaratively load your JavaScript and CSS assets using the `javascript_include_tag` and `stylesheet_link_tag` helpers.
+With Rails you would typically load your JavaScript and CSS assets declaratively using the `javascript_include_tag` and `stylesheet_link_tag` helpers.
 
-For example, you may have top-level "application" CSS located in a file at `/app/assets/stylesheets/application.css`. Likewise, you may have some global JavaScript located in a file at `/app/javascript/application.js`.
+For example, you may have top-level "application" styles located in a file at `/app/assets/stylesheets/application.css`. Likewise, you may have some global JavaScript located in a file at `/app/javascript/application.js`.
 
-You would manually and declaratively include those two files in your application layout, something like this:
+You would manually and declaratively include those two files in each of your layouts, something like this:
 
 ```erb
 <%# /app/views/layouts/application.html.erb %>
@@ -142,7 +141,9 @@ The main problem is that you have to keep track of all these assets, and make su
 
 When side loading your JavaScript, Typescript and CSS with Proscenium, they are automatically included alongside your views, partials, layouts, and components, and only when needed.
 
-Side loading works by looking for a JS/TS/CSS file with the same name as your view, partial, layout or component. For example, if you have a view at `app/views/users/index.html.erb`, then Proscenium will look for a JS/TS/CSS file at `app/views/users/index.js`, `app/views/users/index.ts` or `app/views/users/index.css`. If it finds one, it will include it in the HTML for that view.
+Side loading works by looking for a JS/TS/CSS file with the same name as your view, partial, layout or component. For example, if you have a view at `app/views/users/index.html.erb`, then Proscenium will look for a JS and CSS file at `app/views/users/index.js` (or TypeScript with a .ts extension) and `app/views/users/index.css`. If it finds one, it will automatically include it in the HTML for that view. And only for that view.
+
+This allows you to keep your assets organized alongside the views, partials, and components that use them, without having to manually track and include them. It also means only the assets that are needed are included.
 
 JSX is also supported for JavaScript and Typescript. Simply use the `.jsx` or `.tsx` extension instead of `.js` or `.ts`.
 
@@ -273,6 +274,14 @@ Then just import as normal:
 import React from "react";
 ```
 
+Or if you don't want any bundling at all, simply turn it off application-wide:
+
+```ruby
+config.proscenium.bundle = false
+```
+
+This will mean every asset and import will be loaded independently.
+
 ## Import Maps
 
 > **[WIP]**
@@ -442,8 +451,6 @@ one();
 
 ### Code Splitting
 
-> Available in `>=0.10.0`.
-
 [Side loaded](#side-loading) assets are automatically code split. This means that if you have a file that is imported and used imported several times, and by different files, it will be split off into a separate file.
 
 As an example:
@@ -681,97 +688,8 @@ import { version } from "./package.json";
 console.log(version);
 ```
 
-## Phlex Support
-
-[Phlex](https://www.phlex.fun/) is a framework for building fast, reusable, testable views in pure Ruby. Proscenium works perfectly with Phlex, with support for side-loading, CSS modules, and more. Simply write your Phlex classes and inherit from `Proscenium::Phlex`.
-
-```ruby
-class MyView < Proscenium::Phlex
-  def view_template
-    h1 { 'Hello World' }
-  end
-end
-```
-
-In your layouts, include `Proscenium::Phlex::AssetInclusions`, and call the `include_assets` helper.
-
-```ruby
-class ApplicationLayout < Proscenium::Phlex
-  include Proscenium::Phlex::AssetInclusions # <--
-
-  def view_template(&)
-    doctype
-    html do
-      head do
-        title { 'My Awesome App' }
-        include_assets # <--
-      end
-      body(&)
-    end
-  end
-end
-```
-
-You can specifically include CCS and JS assets using the `include_stylesheets` and `include_javascripts` helpers, allowing you to control where they are included in the HTML.
-
-### Side-loading
-
-Any Phlex class that inherits `Proscenium::Phlex` will automatically be [side-loaded](#side-loading).
-
-### CSS Modules
-
-[CSS Modules](#css-modules) are fully supported in Phlex classes, with access to the [`css_module` helper](#in-your-views) if you need it. However, there is a better and more seemless way to reference CSS module classes in your Phlex classes.
-
-Within your Phlex classes, any class names that begin with `@` will be treated as a CSS module class.
-
-```ruby
-# /app/views/users/show_view.rb
-class Users::ShowView < Proscenium::Phlex
-  def view_template
-    h1 class: :@user_name do
-      @user.name
-    end
-  end
-end
-```
-
-```css
-/* /app/views/users/show_view.module.css */
-.userName {
-  color: red;
-  font-size: 50px;
-}
-```
-
-In the above `Users::ShowView` Phlex class, the `@user_name` class will be resolved to the `userName` class in the `users/show_view.module.css` file.
-
-The view above will be rendered something like this:
-
-```html
-<h1 class="user_name-ABCD1234"></h1>
-```
-
-You can of course continue to reference regular class names in your view, and they will be passed through as is. This will allow you to mix and match CSS modules and regular CSS classes in your views.
-
-```ruby
-# /app/views/users/show_view.rb
-class Users::ShowView < Proscenium::Phlex
-  def view_template
-    h1 class: :[@user_name, :title] do
-      @user.name
-    end
-  end
-end
-```
-
-```html
-<h1 class="user_name-ABCD1234 title">Joel Moss</h1>
-```
-
 ## Cache Busting
 
-> _COMING SOON_
-
 By default, all assets are not cached by the browser. But if in production, you populate the `REVISION` env variable, all CSS and JS URL's will be appended with its value as a query string, and the `Cache-Control` response header will be set to `public` and a max-age of 30 days.
 
 For example, if you set `REVISION=v1`, URL's will be appended with `?v1`: `/my/imported/file.js?v1`.

data/lib/proscenium/builder.rb

@@ -16,6 +16,7 @@ module Proscenium
 
     module Request
       extend FFI::Library
+
       ffi_lib Pathname.new(__dir__).join('ext/proscenium').to_s
 
       enum :environment, [:development, 1, :test, :production]

data/lib/proscenium/css_module/path.rb

@@ -18,7 +18,8 @@ module Proscenium
       unless @css_module_path
         klass = superclass
 
-        while klass.respond_to?(:css_module_path) && !klass.abstract_class
+        while klass.respond_to?(:css_module_path) &&
+              (klass.respond_to?(:abstract_class) ? !klass.abstract_class : true)
           break if (@css_module_path = klass.css_module_path)
 
           klass = klass.superclass

data/lib/proscenium/css_module/transformer.rb

@@ -70,7 +70,7 @@ module Proscenium
       digest = Importer.import(resolved_path)
 
       transformed_path = ''
-      transformed_path = "__#{resolved_path[1..].gsub(%r{[@/\.+]}, '-')}" if Rails.env.development?
+      transformed_path = "__#{resolved_path[1..].gsub(%r{[@/.+]}, '-')}" if Rails.env.development?
       transformed_name = name.to_s
       transformed_name = if transformed_name.start_with?('_')
                            "_#{transformed_name[1..]}-#{digest}#{transformed_path}"

data/lib/proscenium/helper.rb

@@ -40,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

data/lib/proscenium/log_subscriber.rb

@@ -36,5 +36,3 @@ module Proscenium
     end
   end
 end
-
-Proscenium::LogSubscriber.attach_to :proscenium

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,6 +10,7 @@ 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
@@ -28,6 +28,11 @@ module Proscenium
     }
 
     config.after_initialize do |_app|
+      if config.proscenium.logging
+        require 'proscenium/log_subscriber'
+        Proscenium::LogSubscriber.attach_to :proscenium
+      end
+
       ActiveSupport.on_load(:action_view) do
         include Proscenium::Helper
       end

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::Phlex::ReactComponent
+      #   class MyComponent < Proscenium::ReactComponent
       #     self.root_tag = :span
       #   end
       #

data/lib/proscenium/side_load.rb

@@ -116,7 +116,8 @@ module Proscenium
         css_imports = []
 
         klass = obj.class
-        while klass.respond_to?(:source_path) && klass.source_path && !klass.abstract_class
+        while klass.respond_to?(:source_path) && klass.source_path &&
+              (klass.respond_to?(:abstract_class) ? !klass.abstract_class : true)
           if options[:css] == false
             Importer.sideload klass.source_path, **options
           else
@@ -133,7 +134,7 @@ module Proscenium
         # in the ancestry is also sideloaded in addition to the regular CSS files. This is because
         # the CSS module digest will be different for each file, so we only sideload the first CSS
         # module.
-        css_imports.each do |it|
+        css_imports.each do |it| # rubocop:disable Style/ItAssignment
           break if Importer.sideload_css_module(it, **options).present?
         end
 
@@ -142,7 +143,7 @@ module Proscenium
         # The reason why we sideload CSS after JS is because the order of CSS is important.
         # Basically, the layout should be loaded before the view so that CSS cascading works in the
         # right direction.
-        css_imports.reverse_each do |it|
+        css_imports.reverse_each do |it| # rubocop:disable Style/ItAssignment
           Importer.sideload_css it, **options
         end
       end

data/lib/proscenium/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Proscenium
-  VERSION = '0.19.0.beta19'
+  VERSION = '0.19.0'
 end

data/lib/proscenium.rb

@@ -28,7 +28,6 @@ module Proscenium
   autoload :SideLoad
   autoload :CssModule
   autoload :ReactComponentable
-  autoload :Phlex
   autoload :Helper
   autoload :Builder
   autoload :Importer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proscenium
 version: !ruby/object:Gem::Version
-  version: 0.19.0.beta19
+  version: 0.19.0
 platform: x86_64-linux
 authors:
 - Joel Moss
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,34 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.17.0
-- !ruby/object:Gem::Dependency
-  name: phlex-rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: prism
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -72,20 +44,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
-- !ruby/object:Gem::Dependency
-  name: require-hooks
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
 description:
 email:
 - joel@developwithstyle.com
@@ -101,7 +59,6 @@ files:
 - lib/proscenium/bundled_gems.rb
 - lib/proscenium/css_module.rb
 - lib/proscenium/css_module/path.rb
-- lib/proscenium/css_module/rewriter.rb
 - lib/proscenium/css_module/transformer.rb
 - lib/proscenium/ensure_loaded.rb
 - lib/proscenium/ext/proscenium
@@ -114,10 +71,6 @@ files:
 - lib/proscenium/middleware/esbuild.rb
 - lib/proscenium/middleware/ruby_gems.rb
 - lib/proscenium/monkey.rb
-- lib/proscenium/phlex.rb
-- lib/proscenium/phlex/asset_inclusions.rb
-- lib/proscenium/phlex/css_modules.rb
-- lib/proscenium/phlex/react_component.rb
 - lib/proscenium/railtie.rb
 - lib/proscenium/react-manager/index.jsx
 - lib/proscenium/react-manager/react.js

data/lib/proscenium/css_module/rewriter.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require 'prism'
-require 'require-hooks/setup'
-
-module Proscenium
-  module CssModule
-    class Rewriter
-      def self.init(include: [], exclude: [])
-        RequireHooks.source_transform(
-          patterns: include,
-          exclude_patterns: exclude
-        ) do |path, source|
-          source ||= File.read(path)
-          Processor.call(source)
-        end
-      end
-
-      class Processor < Prism::Visitor
-        def self.call(source)
-          visitor = new
-          visitor.visit(Prism.parse(source).value)
-
-          buffer = source.dup
-          annotations = visitor.annotations
-          annotations.sort_by!(&:first)
-
-          annotations.reverse_each do |offset, action|
-            case action
-            when :start
-              buffer.insert(offset, 'class_names(*')
-            when :end
-              buffer.insert(offset, ')')
-            else
-              raise 'Invalid annotation'
-            end
-          end
-
-          buffer
-        end
-
-        def initialize
-          @annotations = []
-        end
-
-        PREFIX = '@'
-
-        attr_reader :annotations
-
-        def visit_assoc_node(node)
-          # Skip if the key is not a symbol or string
-          return if %i[symbol_node string_node].exclude?(node.key.type)
-
-          return if node.key.type == :symbol_node && node.key.value != 'class'
-          return if node.key.type == :string_node && node.key.content != 'class'
-
-          value = node.value
-          type = value.type
-
-          if (type == :symbol_node && value.value.start_with?(PREFIX)) ||
-             (type == :array_node && value.elements.any? { |it| it.value.start_with?(PREFIX) })
-            build_annotation value
-          end
-        end
-
-        def build_annotation(value)
-          location = value.location
-
-          @annotations <<
-            [location.start_character_offset, :start] <<
-            [location.end_character_offset, :end]
-        end
-      end
-    end
-  end
-end

data/lib/proscenium/phlex/asset_inclusions.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium::Phlex::AssetInclusions
-  def include_stylesheets
-    comment { '[PROSCENIUM_STYLESHEETS]' }
-  end
-
-  def include_javascripts
-    comment { '[PROSCENIUM_JAVASCRIPTS]' }
-  end
-
-  def include_assets
-    include_stylesheets
-    include_javascripts
-  end
-end

data/lib/proscenium/phlex/css_modules.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  module Phlex::CssModules
-    def self.included(base)
-      base.extend CssModule::Path
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # Set of CSS module paths that have been resolved after being transformed from 'class' HTML
-      # attributes. See #process_attributes. This is here because Phlex caches attributes. Which
-      # means while the CSS class names will be transformed, any resolved paths will be lost in
-      # subsequent requests.
-      attr_accessor :resolved_css_module_paths
-    end
-
-    def before_template
-      self.class.resolved_css_module_paths ||= Concurrent::Set.new
-      super
-    end
-
-    def after_template
-      self.class.resolved_css_module_paths ||= Concurrent::Set.new
-      self.class.resolved_css_module_paths.each do |path|
-        Proscenium::Importer.import path, sideloaded: true
-      end
-
-      super
-    end
-
-    # Resolve and side load any CSS modules in the "class" attributes, where a CSS module is a class
-    # name beginning with a `@`. The class name is resolved to a CSS module name based on the file
-    # system path of the Phlex class, and any CSS file is side loaded.
-    #
-    # For example, the following will side load the CSS module file at
-    # app/components/user/component.module.css, and add the CSS Module name `user_name` to the
-    # <div>.
-    #
-    #   # app/components/user/component.rb
-    #   class User::Component < Proscenium::Phlex
-    #     def view_template
-    #       div class: :@user_name do
-    #         'Joel Moss'
-    #       end
-    #     end
-    #   end
-    #
-    # Additionally, any class name containing a `/` is resolved as a CSS module path. Allowing you
-    # to use the same syntax as a CSS module, but without the need to manually import the CSS file.
-    #
-    # For example, the following will side load the CSS module file at /lib/users.module.css, and
-    # add the CSS Module name `name` to the <div>.
-    #
-    #   class User::Component < Proscenium::Phlex
-    #     def view_template
-    #       div class: '/lib/users@name' do
-    #         'Joel Moss'
-    #       end
-    #     end
-    #   end
-    #
-    # @raise [Proscenium::CssModule::Resolver::NotFound] If a CSS module file is not found for the
-    #   Phlex class file path.
-    def process_attributes(**attributes)
-      if attributes.key?(:class) && (attributes[:class] = tokens(attributes[:class])).include?('@')
-        names = attributes[:class].is_a?(Array) ? attributes[:class] : attributes[:class].split
-
-        self.class.resolved_css_module_paths ||= Concurrent::Set.new
-
-        attributes[:class] = cssm.class_names(*names).map do |name, path|
-          self.class.resolved_css_module_paths << path if path
-          name
-        end
-      end
-
-      attributes
-    end
-  end
-end

data/lib/proscenium/phlex/react_component.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  # Renders a <div> for use with React components, with data attributes specifying the component
-  # path and props.
-  #
-  # If a block is given, it will be yielded within the div, allowing for a custom "loading" UI. If
-  # no block is given, then a "loading..." text will be rendered. It is intended that the component
-  # is mounted to this div, and the loading UI will then be replaced with the component's rendered
-  # output.
-  #
-  # You can pass props to the component in the `:props` keyword argument.
-  class Phlex::ReactComponent < Phlex
-    self.abstract_class = true
-
-    include ReactComponentable
-
-    # Override this to provide your own loading UI.
-    #
-    # @example
-    #   def view_template(**attributes, &block)
-    #     super do
-    #       'Look at me! I am loading now...'
-    #     end
-    #   end
-    #
-    # @yield the given block to a `div` within the top level component div.
-    def view_template(**attributes, &)
-      send(root_tag, **{ data: data_attributes }.deep_merge(attributes), &)
-    end
-  end
-end

data/lib/proscenium/phlex.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'phlex-rails'
-
-module Proscenium
-  class Phlex < ::Phlex::HTML
-    extend ActiveSupport::Autoload
-
-    autoload :CssModules
-    autoload :ReactComponent
-    autoload :AssetInclusions
-
-    include Proscenium::SourcePath
-    include Proscenium::CssModule
-    include CssModules
-    include AssetInclusions
-
-    module Sideload
-      def before_template
-        Proscenium::SideLoad.sideload_inheritance_chain self,
-                                                        helpers.controller.sideload_assets_options
-
-        super
-      end
-    end
-
-    class_attribute :sideload_assets_options
-
-    class << self
-      attr_accessor :abstract_class
-
-      def inherited(child)
-        child.prepend Sideload
-
-        super
-      end
-
-      def sideload_assets(value)
-        self.sideload_assets_options = value
-      end
-    end
-  end
-end