proscenium 0.15.0.beta.6-x86_64-linux → 0.17.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b4d428fbf68baaf6031e7813f622929337a1c620fba5f8b27685feb024999ef
-  data.tar.gz: 2c1608e82bdf642496e150b5873d897f98c71469ae83a51e1704e07a4e2215cb
+  metadata.gz: fb3963b8da2f0e97bc51c8a134fc2bd19eb4295f12804e6822f461fc550e4b09
+  data.tar.gz: cebcaa110542366aad9bb30eec908ba4696cef75b89f69b249b17b5307db9d22
 SHA512:
-  metadata.gz: 6a847f4fdb0c7d31a04ed4bdf9b0ce557f6d842971e4ffe599bbebc41c89e8be6261f048078d9c896c340dbedbae629152cbe00e04c94e87c56c412ecb979fcd
-  data.tar.gz: 3c094ab074aef75e13d35298262bd2aa84da94aa9a21f1decf08b333018cfd4d247b51ec2feab7d72a0d2db91a5f0b22e41834986735ee80b0cdc6ab7774aa02
+  metadata.gz: a53bdec45fe3db5a9edb00611ffa676db210211aad1fa99648620ff4fe61110871837d8c786aa79875d4ced4ef9b0771d66468df5c9bd4747f76cbae0a12360a
+  data.tar.gz: ee15a6b0f8fb6454ec7947fe4cb6090c266248502e3a24bfe7fb7e64653c58a75042a23ca05e51ed44d071e293f5f75ea7115b70065dbe2d87cb2821e90d3ec8

data/README.md

@@ -1,13 +1,20 @@
-# Proscenium - Modern client-side development for Rails
+# Proscenium - Integrated Frontend Development for Rails
 
-Proscenium treats your client-side code as first class citizens of your Rails app, and assumes a "fast by default" internet. It bundles your JavaScript and CSS in real time, on demand, and with zero configuration.
+> 🗣️ prow · see · nee · uhm
+>
+> _noun_: **proscenium**
+>
+> - _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.
 
 **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 - just the browser!
+- 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!
+- NO additional process or server - Just run `rails s`!
+- Transforms newer JavaScript and CSS syntax to older syntax for older browsers.
 - Deep integration with Rails.
 - Automatically side-load your layouts, views, and partials.
 - Import from NPM, URL's, and locally.
@@ -22,7 +29,6 @@ Proscenium treats your client-side code as first class citizens of your Rails ap
 - [Client-Side Code Anywhere](#client-side-code-anywhere)
 - [Side Loading](#side-loading)
 - [Importing](#importing-assets)
-  - [URL Imports](#url-imports)
   - [Local Imports](#local-imports)
 - [Import Maps](#import-maps)
 - [Source Maps](#source-maps)
@@ -70,7 +76,9 @@ Add this line to your Rails application's Gemfile, and you're good to go:
 gem 'proscenium'
 ```
 
-Please note that Proscenium is designed solely for use with Rails, so will not work - at least out of the box - anywhere else.
+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.
 
 ## Client-Side Code Anywhere
 
@@ -82,23 +90,21 @@ Simply put your JS(X) and CSS anywhere you want, and they will be served by your
 
 Using the examples above...
 
-- `app/views/users/index.js` => `https://yourapp.com/app/views/users/index.js`
-- `app/views/layouts/application.css` => `https://yourapp.com/app/views/layouts/application.css`
-- `lib/utils.js` => `https://yourapp.com/lib/utils.js`
-- `app/components/menu_component.jsx` => `https://yourapp.com/app/components/menu_component.jsx`
-- `config/properties.css` => `https://yourapp.com/config/properties.css`
+- `app/views/users/index.js` => `https://localhost:3000/app/views/users/index.js`
+- `app/views/layouts/application.css` => `https://localhost:3000/app/views/layouts/application.css`
+- `lib/utils.js` => `https://localhost:3000/lib/utils.js`
+- `app/components/menu_component.jsx` => `https://localhost:3000/app/components/menu_component.jsx`
+- `config/properties.css` => `https://localhost:3000/config/properties.css`
 
 ## Side Loading
 
-> Prior to **0.10.0**, only assets with the extension `.js`, `.ts` and `.css` were side loaded. From 0.10.0, all assets are side loaded, including `.jsx`, `.tsx`, and `.module.css`. Also partials were not side loaded prior to 0.10.0.
-
-Proscenium is best experienced when you side load your assets.
+Proscenium is best experienced when your assets are automtically 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.
 
-For example, you may have top-level "application" CSS located in a file at `/app/assets/application.css`. Likewise, you may have some global JavaScript located in a file at `/app/assets/application.js`.
+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`.
 
 You would manually and declaratively include those two files in your application layout, something like this:
 
@@ -177,45 +183,55 @@ Now, in your layout and view, replace the `javascript_include_tag` and `styleshe
 </html>
 ```
 
-On each page request, Proscenium will check if any of your views, layouts and partials have a
-JS/TS/CSS file of the same name, and then include them wherever your placed the `include_assets`
-helper.
+On each page request, Proscenium will check if any of your views, layouts and partials have a JS/TS/CSS file of the same name, and then include them wherever your placed the `include_assets` helper.
+
+Now you never have to remember to include your assets again. Just create them alongside your views, partials and layouts, and Proscenium will take care of the rest.
+
+Side loading is enabled by default, but you can disable it by setting `config.proscenium.side_load` to `false` in your `/config/application.rb`.
+
+There are also `include_stylesheets` and `include_javascripts` helpers to allow you to control where the CSS and JS assets are included in the HTML. These helpers should be used instead of `include_assets` if you want to control exactly where the assets are included.
 
-Now you never have to remember to include your assets again. Just create them alongside your views,
-partials and layouts, and Proscenium will take care of the rest.
+## Bundling
 
-Side loading is enabled by default, but you can disable it by setting `config.proscenium.side_load`
-to `false` in your `/config/application.rb`.
+To bundle a file means to inline any imported dependencies into the file itself. This process is recursive so dependencies of dependencies (and so on) will also be inlined.
 
-There are also `include_stylesheets` and `include_javascripts` helpers to allow you to control where
-the CSS and JS assets are included in the HTML. These helpers should be used instead of
-`include_assets` if you want to control exactly where the assets are included.
+Proscenium will bundle by default, and in real time. So there is no separate build step or pre-compilation.
 
-## Importing Assets
+Proscenium supports importing JS, JSX, TS, TSX, CSS and SVG from NPM, by URL, your local app, and even from other Ruby Gems.
 
-Proscenium supports importing JS, JSX, TS, TSX, CSS and SVG from NPM, by URL, your local app, and even from Ruby Gems.
+Both static ([`import`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import)) and dynamic ([`import()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import)) imports are supported for JavaScript and TypeScript, and can be used to import JS, TS, JSX, TSX, JSON, CSS and SVG files.
 
-Imported files are bundled together in real time. So no build step or pre-compilation is needed.
+The [`@import`](https://developer.mozilla.org/en-US/docs/Web/CSS/@import) CSS at-rule is supported for CSS.
 
-Imports are assumed to be JS files, so there is no need to specify the file extesnion in such cases. But you can if you like. All other file types must be specified using their full file name and extension.
+### Non-analyzable imports
 
-### URL Imports
+Import paths are currently only bundled if they are a string literal or a glob pattern. Other forms of import paths are not bundled, and are instead preserved verbatim in the generated output. This is because bundling is a compile-time operation and Proscenium doesn't support all forms of run-time path resolution.
 
-Any import beginning with `http://` or `https://` will be fetched from the URL provided. For example:
+Here are some examples:
 
 ```js
-import React from "https://esm.sh/react";
-```
+// Analyzable imports (will be bundled)
+import "pkg";
+import("pkg");
+import(`./locale-${foo}.json`);
 
-```css
-@import "https://cdn.jsdelivr.net/npm/bootstrap@5.2.0/dist/css/bootstrap.min.css";
+// Non-analyzable imports (will not be bundled)
+import(`pkg/${foo}`);
 ```
 
-URL imports are cached, so that each import is only fetched once per server restart.
+The way to work around non-analyzable imports is to mark the package containing this problematic code as [unbundled](#Unbundling) so that it's not included in the bundle. You will then need to ensure that a copy of the external package is available to your bundled code at run-time.
 
 ### Import from NPM (`node_modules`)
 
-Bare imports (imports not beginning with `./`, `/`, `https://`, `http://`) are fully supported, and will use your package manager of choice (eg, NPM, Yarn, pnpm) via the `package.json` file:
+Bare imports (imports not beginning with `./`, `/`, `https://`, `http://`) are fully supported, and will use your package manager of choice (eg, NPM, Yarn, pnpm) via the `package.json` file located at the root of your Rails app.
+
+Install the package you want to import using your package manager of choice...
+
+```
+npm install react
+```
+
+...and then import it as you would any other package.
 
 ```js
 import React from "react";
@@ -223,26 +239,18 @@ import React from "react";
 
 ### Local Imports
 
-And of course you can import your own code, using relative or absolute paths (file extension is optional):
+And of course you can import your own code, using relative or absolute paths (file extension is optional, and absolute paths use your Rails root as the base):
 
-```js /app/views/layouts/application.js
+```js
 import utils from "/lib/utils";
-```
-
-```js /lib/utils.js
 import constants from "./constants";
+import Header from "/app/components/header";
 ```
 
-```css /app/views/layouts/application.css
+```css
 @import "/lib/reset";
 ```
 
-```css /lib/reset.css
-body {
-  /* some styles... */
-}
-```
-
 ### Unbundling
 
 Sometimes you don't want to bundle an import. For example, you want to ensure that only one instance of React is loaded. In this cases, you can use the `unbundle` prefix
@@ -253,7 +261,7 @@ import React from "unbundle:react";
 
 This only works any bare and local imports.
 
-You can also use the `unbundle` prefix in your import map, which ensures that all imports of a particular path is always unbundled:
+You can also use the `unbundle` prefix in your [import map](#import-maps), which ensures that all imports of a particular path is always unbundled:
 
 ```json
 {
@@ -411,11 +419,11 @@ import translations from "@proscenium/i18n";
 
 ## Javascript
 
-By default, Proscenium's output will take advantage of all modern JS features. For example, `a !== void 0 && a !== null ? a : b` will become `a ?? b` when minifying (enabled by default in production), which makes use of syntax from the ES2020 version of JavaScript.
+By default, Proscenium's output will take advantage of all modern JS features from the ES2022 spec and earlier. For example, `a !== void 0 && a !== null ? a : b` will become `a ?? b` when minifying (enabled by default in production), which makes use of syntax from the ES2020 version of JavaScript. Any syntax feature that is not supported by ES2020 will be transformed into older JavaScript syntax that is more widely supported.
 
 ### Tree Shaking
 
-Tree shaking is the term the JavaScript community uses for dead code elimination, a common compiler optimization that automatically removes unreachable code. Tree shaking is enabled by default in Proascenium.
+Tree shaking is the term the JavaScript community uses for dead code elimination, a common compiler optimization that automatically removes unreachable code. Tree shaking is enabled by default in Proscenium.
 
 ```javascript
 function one() {
@@ -491,6 +499,8 @@ Note that by default, Proscenium's output will take advantage of all modern CSS
 
 The new CSS nesting syntax is supported, and transformed into non-nested CSS for older browsers.
 
+Proscenium will also automatically insert vendor prefixes so that your CSS will work in older browsers.
+
 ### Importing CSS from JavaScript
 
 You can also import CSS from JavaScript. When you do this, Proscenium will automatically append each stylesheet to the document's head as a `<link>` element.
@@ -835,7 +845,7 @@ Proscenium brings back RJS! Any path ending in .rjs will be served from your Rai
 
 Proscenium will serve files ending with any of these extension: `js,mjs,ts,css,jsx,tsx` from the following directories, and their sub-directories of your Rails application's root: `/app`, `/lib`, `/config`, `/node_modules`, `/vendor`.
 
-So a file at `/app/views/users/index.js` will be served from `https://yourapp.com/app/views/users/index.js`.
+So a file at `/app/views/users/index.js` will be served from `https://localhost:3000/app/views/users/index.js`.
 
 You can continue to access any file in the `/public` directory as you normally would. Proscenium will not process files in the `/public` directory.
 

data/lib/proscenium/builder.rb

@@ -84,15 +84,15 @@ module Proscenium
     end
 
     def self.build_to_path(path, root: nil, base_url: nil)
-      new(root: root, base_url: base_url).build_to_path(path)
+      new(root:, base_url:).build_to_path(path)
     end
 
     def self.build_to_string(path, root: nil, base_url: nil)
-      new(root: root, base_url: base_url).build_to_string(path)
+      new(root:, base_url:).build_to_string(path)
     end
 
     def self.resolve(path, root: nil)
-      new(root: root).resolve(path)
+      new(root:).resolve(path)
     end
 
     def initialize(root: nil, base_url: nil)

data/lib/proscenium/helper.rb

@@ -15,10 +15,18 @@ module Proscenium
     # building with Proscenium. It's important to note that `include_assets` will not call this, as
     # 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
+    # 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])
+        if !path.start_with?("./", "../")
+          path.prepend DEFAULT_RAILS_ASSET_PATHS[options[:type]]
+        end
+
         result = Proscenium::Builder.build_to_path(path, base_url: request.base_url)
-        return result.split('::').last.delete_prefix 'public'
+        return result.split("::").last.delete_prefix "public"
       end
 
       super

data/lib/proscenium/importer.rb

@@ -25,7 +25,7 @@ module Proscenium
       #   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, **options)
+      def import(filepath = nil, resolve: nil, **)
         self.imported ||= {}
 
         filepath = Resolver.resolve(resolve) if !filepath && resolve
@@ -34,7 +34,7 @@ module Proscenium
         unless self.imported.key?(filepath)
           # ActiveSupport::Notifications.instrument('sideload.proscenium', identifier: value)
 
-          self.imported[filepath] = { **options }
+          self.imported[filepath] = { ** }
           self.imported[filepath][:digest] = Utils.digest(filepath) if css_module
         end
 
@@ -61,19 +61,36 @@ module Proscenium
       #
       # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
       def sideload(filepath, **options)
+        return if !Proscenium.config.side_load || (options[:js] == false && options[:css] == false)
+
+        sideload_js(filepath, **options) unless options[:js] == false
+        sideload_css(filepath, **options) unless options[:css] == false
+      end
+
+      def sideload_js(filepath, **options)
         return unless Proscenium.config.side_load
 
         filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
         filepath = filepath.sub_ext('')
 
-        import_if_exists = lambda do |x|
+        JS_EXTENSIONS.find do |x|
           if (fp = filepath.sub_ext(x)).exist?
             import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
           end
         end
+      end
 
-        JS_EXTENSIONS.find(&import_if_exists) unless options[:js] == false
-        CSS_EXTENSIONS.find(&import_if_exists) unless options[:css] == false
+      def sideload_css(filepath, **options)
+        return unless Proscenium.config.side_load
+
+        filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
+        filepath = filepath.sub_ext('')
+
+        CSS_EXTENSIONS.find do |x|
+          if (fp = filepath.sub_ext(x)).exist?
+            import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
+          end
+        end
       end
 
       def each_stylesheet(delete: false)

data/lib/proscenium/log_subscriber.rb

@@ -16,7 +16,7 @@ module Proscenium
       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 = "  #{color('[Proscenium]', nil, bold: true)} Building (to path) #{path}"
         message << " (Duration: #{event.duration.round(1)}ms | " \
                    "Allocations: #{event.allocations}#{cached})"
       end
@@ -27,7 +27,7 @@ module Proscenium
       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)} Building #{path}"
         message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
       end
     end

data/lib/proscenium/middleware/esbuild.rb

@@ -15,7 +15,7 @@ module Proscenium
                             detail[:text]
                           end
 
-          super(args)
+          super
         end
       end
 

data/lib/proscenium/middleware.rb

@@ -11,14 +11,13 @@ module Proscenium
     autoload :Esbuild
     autoload :Engines
     autoload :Runtime
-    autoload :Url
 
     def initialize(app)
       @app = app
 
       chunks_path = Rails.public_path.join('assets').to_s
       headers = Rails.application.config.public_file_server.headers || {}
-      @chunk_handler = ::ActionDispatch::FileHandler.new(chunks_path, headers: headers)
+      @chunk_handler = ::ActionDispatch::FileHandler.new(chunks_path, headers:)
     end
 
     def call(env)
@@ -41,7 +40,6 @@ module Proscenium
     end
 
     def find_type(request)
-      return Url if request.path.match?(%r{^/https?%3A%2F%2F})
       return Runtime if request.path.match?(%r{^/@proscenium/})
       return Esbuild if Pathname.new(request.path).fnmatch?(app_path_glob, File::FNM_EXTGLOB)
 

data/lib/proscenium/phlex/react_component.rb

@@ -25,8 +25,8 @@ module Proscenium
     #   end
     #
     # @yield the given block to a `div` within the top level component div.
-    def view_template(**attributes, &block)
-      send root_tag, **{ data: data_attributes }.deep_merge(attributes), &block
+    def view_template(**attributes, &)
+      send(root_tag, **{ data: data_attributes }.deep_merge(attributes), &)
     end
   end
 end

data/lib/proscenium/railtie.rb

@@ -88,7 +88,7 @@ module Proscenium
         index = app.config.public_file_server.index_name || 'index'
 
         app.middleware.insert_after(ActionDispatch::Static, ActionDispatch::Static,
-                                    root.join('public').to_s, index: index, headers: headers)
+                                    root.join('public').to_s, index:, headers:)
       end
     end
   end

data/lib/proscenium/side_load.rb

@@ -76,7 +76,7 @@ module Proscenium
             next unless imports.key?(inpath)
 
             if (import = imports[inpath]).delete(:lazy)
-              scripts[inpath] = import.merge(outpath: outpath)
+              scripts[inpath] = import.merge(outpath:)
             else
               opts = import[:js].is_a?(Hash) ? import[:js] : {}
               out << helpers.javascript_include_tag(outpath, extname: false, **opts)
@@ -127,16 +127,28 @@ module Proscenium
           options[k] = obj.instance_eval(&options[k]) if options[k].is_a?(Proc)
         end
 
+        css_imports = []
+
         klass = obj.class
         while klass.respond_to?(:source_path) && klass.source_path && !klass.abstract_class
           if klass.respond_to?(:sideload)
             klass.sideload options
-          else
+          elsif options[:css] == false
             Importer.sideload klass.source_path, **options
+          else
+            Importer.sideload_js klass.source_path, **options
+            css_imports << klass.source_path
           end
 
           klass = klass.superclass
         end
+
+        # 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 i9n the
+        # right direction.
+        css_imports.reverse_each do |it|
+          Importer.sideload_css it, **options
+        end
       end
     end
   end

data/lib/proscenium/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Proscenium
-  VERSION = '0.15.0.beta.6'
+  VERSION = '0.17.0'
 end

data/lib/proscenium.rb

@@ -8,6 +8,13 @@ module Proscenium
   FILE_EXTENSIONS = ['js', 'mjs', 'ts', 'jsx', 'tsx', 'css', 'js.map', 'mjs.map', 'jsx.map',
                      'ts.map', 'tsx.map', 'css.map'].freeze
 
+  # Default paths for Rails assets. Used by the `compute_asset_path` helper to maintain Rails
+  # default conventions of where JS and CSS files are located.
+  DEFAULT_RAILS_ASSET_PATHS = {
+    stylesheet: 'app/assets/stylesheets/',
+    javascript: 'app/javascript/'
+  }.freeze
+
   ALLOWED_DIRECTORIES = 'app,lib,config,vendor,node_modules'
 
   # Environment variables that should always be passed to the builder.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proscenium
 version: !ruby/object:Gem::Version
-  version: 0.15.0.beta.6
+  version: 0.17.0
 platform: x86_64-linux
 authors:
 - Joel Moss
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.0'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.0'
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.3
+        version: 1.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.3
+        version: 1.17.0
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -106,7 +106,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.0'
@@ -116,7 +116,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.0'
@@ -171,7 +171,6 @@ files:
 - lib/proscenium/middleware/engines.rb
 - lib/proscenium/middleware/esbuild.rb
 - lib/proscenium/middleware/runtime.rb
-- lib/proscenium/middleware/url.rb
 - lib/proscenium/monkey.rb
 - lib/proscenium/phlex.rb
 - lib/proscenium/phlex/asset_inclusions.rb
@@ -214,14 +213,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: The engine powering your Rails frontend

data/lib/proscenium/middleware/url.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Proscenium
-  class Middleware
-    # Handles requests for URL encoded URL's.
-    class Url < Esbuild
-      private
-
-      # @override [Esbuild] It's a URL, so always assume it is renderable (we won't actually know
-      #   until it's downloaded).
-      def renderable?
-        true
-      end
-    end
-  end
-end