RubyGems - proscenium - Versions diffs - 0.13.0-arm64-darwin → 0.15.0.beta.1-arm64-darwin - Mend

proscenium 0.13.0-arm64-darwin → 0.15.0.beta.1-arm64-darwin

Files changed (22) hide show

checksums.yaml +4 -4
data/README.md +63 -54
data/lib/proscenium/builder.rb +62 -19
data/lib/proscenium/css_module/transformer.rb +4 -2
data/lib/proscenium/ensure_loaded.rb +6 -6
data/lib/proscenium/ext/proscenium +0 -0
data/lib/proscenium/ext/proscenium.h +16 -1
data/lib/proscenium/helper.rb +23 -70
data/lib/proscenium/importer.rb +2 -6
data/lib/proscenium/libs/react-manager/index.jsx +56 -36
data/lib/proscenium/log_subscriber.rb +14 -2
data/lib/proscenium/middleware/esbuild.rb +2 -2
data/lib/proscenium/monkey.rb +67 -32
data/lib/proscenium/phlex/asset_inclusions.rb +4 -83
data/lib/proscenium/phlex.rb +9 -1
data/lib/proscenium/railtie.rb +21 -16
data/lib/proscenium/react_componentable.rb +3 -3
data/lib/proscenium/side_load.rb +120 -6
data/lib/proscenium/version.rb +1 -1
data/lib/proscenium/view_component.rb +7 -1
data/lib/proscenium.rb +10 -0
metadata +3 -3

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 504d8ab4fde95d64a7800b7406ac1cb5e9de3757277729bd64f84a80a89d0363
-  data.tar.gz: 9dac30d044bac3f9c3c8b6a82721072dbe58a540a36d6538cc3ae29eea31a2ba
+  metadata.gz: 777426aa0b313a8929c7960097ab90d837999611b4225f3fa0dde20a37c8266f
+  data.tar.gz: df51b6365052138666827992b79d749a02f1c94aa3f0a0d308874cfd3914550a
 SHA512:
-  metadata.gz: b828294555e4ed9a3f9875785d09193266b7de9d07cbda5bf3cafe06eff2e3825600dbf6539821c6ffd8f792aba3305b877c174c2337fca6563c7cc9bb6a2849
-  data.tar.gz: 37e577a37203199fdf55eb560521e0f1b5f47ad854ee19f147ab372792a6811a4eef86ea8faa7ddd9a6330b31c7d40ddbd0f90e7804044e31fa205eef1fa4ad9
+  metadata.gz: 859c73ab1b9fb1c2a0231d759d3eb8e0bd217be7855e785123818bf2d98a7690ab528a00b69bec329ed0043b35f68d6c82b634a6de7f1829b967a91d95f957f3
+  data.tar.gz: 98339328e3f83dd854a636f27f0d44d4a8785673d230f90046c0c2be6b3ffe317e8a0b73491e6e1404d3d0b69e832ab459b0c5a67042ce25b96b12e5420ebe3b

data/README.md CHANGED Viewed

@@ -58,8 +58,8 @@ Getting started obviously depends on whether you are adding Proscenium to an exi
 - [Getting Started with a new Rails app](https://github.com/joelmoss/proscenium/blob/master/docs/guides/new_rails_app.md)
 - Getting Started with an existing Rails app
   - [Migrate from Sprockets](docs/guides/migrate_from_sprockets.md)
-  - Migrate from Propshaft *[Coming soon]*
-  - Migrate from Webpacker *[Coming soon]*
+  - Migrate from Propshaft _[Coming soon]_
+  - Migrate from Webpacker _[Coming soon]_
 - [Render a React component with Proscenium](docs/guides/basic_react.md)
 ## Installation
@@ -162,29 +162,34 @@ Your application layout is at `/app/views/layouts/application.hml.erb`, and the
 - `/app/views/users/index.js`
 - `/app/views/users/_user.js` (partial)
-Now, in your layout and view, replace the `javascript_include_tag` and `stylesheet_link_tag` helpers with the `include_stylesheets` and `include_javascripts` helpers from Proscenium. Something like this:
+Now, in your layout and view, replace the `javascript_include_tag` and `stylesheet_link_tag` helpers with the `include_asset` helper from Proscenium. Something like this:
 ```erb
 <!DOCTYPE html>
 <html>
   <head>
     <title>Hello World</title>
-    <%= include_stylesheets %>
+    <%= include_assets # <-- %>
   </head>
   <body>
     <%= yield %>
-    <%= include_javascripts type: 'module', defer: true %>
   </body>
 </html>
 ```
-> NOTE that Proscenium is desiged to work with modern JavaAscript, and assumes [ESModules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules) are used everywhere. This is why the `type` attribute is set to `module` in the example above. If you are not using ESModules, then you can omit the `type` attribute.
+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 your views, layouts and partials have a JS/TS/CSS file of the same name, and then include them wherever your placed the `include_stylesheets` and `include_javascripts` helpers.
+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.
-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`.
-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.
 ## Importing Assets
@@ -199,11 +204,11 @@ Imports are assumed to be JS files, so there is no need to specify the file exte
 Any import beginning with `http://` or `https://` will be fetched from the URL provided. For example:
 ```js
-import React from 'https://esm.sh/react'
+import React from "https://esm.sh/react";
 ```
 ```css
-@import 'https://cdn.jsdelivr.net/npm/bootstrap@5.2.0/dist/css/bootstrap.min.css';
+@import "https://cdn.jsdelivr.net/npm/bootstrap@5.2.0/dist/css/bootstrap.min.css";
 ```
 URL imports are cached, so that each import is only fetched once per server restart.
@@ -213,7 +218,7 @@ URL imports are cached, so that each import is only fetched once per server rest
 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:
 ```js
-import React from 'react'
+import React from "react";
 ```
 ### Local Imports
@@ -221,15 +226,15 @@ import React from 'react'
 And of course you can import your own code, using relative or absolute paths (file extension is optional):
 ```js /app/views/layouts/application.js
-import utils from '/lib/utils'
+import utils from "/lib/utils";
 ```
 ```js /lib/utils.js
-import constants from './constants'
+import constants from "./constants";
 ```
 ```css /app/views/layouts/application.css
-@import '/lib/reset';
+@import "/lib/reset";
 ```
 ```css /lib/reset.css
@@ -243,7 +248,7 @@ body {
 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
 ```js
-import React from 'unbundle:react'
+import React from "unbundle:react";
 ```
 This only works any bare and local imports.
@@ -261,7 +266,7 @@ You can also use the `unbundle` prefix in your import map, which ensures that al
 Then just import as normal:
 ```js
-import React from 'react'
+import React from "react";
 ```
 ## Import Maps
@@ -280,7 +285,7 @@ Just create `config/import_map.json` and specify the imports you want to use. Fo
     "react": "https://esm.sh/react@18.2.0",
     "start": "/lib/start.js",
     "common": "/lib/common.css",
-    "@radix-ui/colors/": "https://esm.sh/@radix-ui/colors@0.1.8/",
+    "@radix-ui/colors/": "https://esm.sh/@radix-ui/colors@0.1.8/"
   }
 }
 ```
@@ -288,26 +293,29 @@ Just create `config/import_map.json` and specify the imports you want to use. Fo
 Using the above import map, we can do...
 ```js
-import { useCallback } from 'react'
-import startHere from 'start'
-import styles from 'common'
+import { useCallback } from "react";
+import startHere from "start";
+import styles from "common";
 ```
 and for CSS...
 ```css
-@import 'common';
-@import '@radix-ui/colors/blue.css';
+@import "common";
+@import "@radix-ui/colors/blue.css";
 ```
 You can also write your import map in JavaScript instead of JSON. So instead of `config/import_map.json`, create `config/import_map.js`, and define an anonymous function. This function accepts a single `environment` argument.
 ```js
-env => ({
+(env) => ({
   imports: {
-    react: env === 'development' ? 'https://esm.sh/react@18.2.0?dev' : 'https://esm.sh/react@18.2.0'
-  }
-})
+    react:
+      env === "development"
+        ? "https://esm.sh/react@18.2.0?dev"
+        : "https://esm.sh/react@18.2.0",
+  },
+});
 ```
 ## Source Maps
@@ -344,8 +352,8 @@ This assumes that the environment variable of the same name has already been def
 These declared environment variables will be replaced with constant expressions, allowing you to use this like this:
 ```js
-console.log(proscenium.env.RAILS_ENV) // console.log("development")
-console.log(proscenium.env.RAILS_ENV === 'development') // console.log(true)
+console.log(proscenium.env.RAILS_ENV); // console.log("development")
+console.log(proscenium.env.RAILS_ENV === "development"); // console.log(true)
 ```
 The `RAILS_ENV` and `NODE_ENV` environment variables will always automatically be declared for you.
@@ -356,24 +364,24 @@ Environment variables are particularly powerful in aiding [tree shaking](#tree-s
 ```js
 function start() {
-  console.log("start")
+  console.log("start");
 }
 function doSomethingDangerous() {
-  console.log("resetDatabase")
+  console.log("resetDatabase");
 }
-proscenium.env.RAILS_ENV === "development" && doSomethingDangerous()
+proscenium.env.RAILS_ENV === "development" && doSomethingDangerous();
-start()
+start();
 ```
 In development the above code will be transformed into the following code, discarding the definition, and call to`doSomethingDangerous()`.
 ```js
 function start() {
-  console.log("start")
+  console.log("start");
 }
-start()
+start();
 ```
 Please note that for security reasons environment variables are not replaced in URL imports.
@@ -381,7 +389,7 @@ Please note that for security reasons environment variables are not replaced in
 An undefined environment variable will be replaced with `undefined`.
 ```js
-console.log(proscenium.env.UNKNOWN) // console.log((void 0).UNKNOWN)
+console.log(proscenium.env.UNKNOWN); // console.log((void 0).UNKNOWN)
 ```
 This means that code that relies on this will not be tree shaken. You can work around this by using the [optional chaining operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining):
@@ -397,7 +405,7 @@ if (typeof proscenium.env?.UNKNOWN !== "undefined") {
 Basic support is provided for importing your Rails locale files from `config/locales/*.yml`, exporting them as JSON.
 ```js
-import translations from '@proscenium/i18n'
+import translations from "@proscenium/i18n";
 // translations.en.*
 ```
@@ -411,12 +419,12 @@ Tree shaking is the term the JavaScript community uses for dead code elimination
 ```javascript
 function one() {
-  console.log('one')
+  console.log("one");
 }
 function two() {
-  console.log('two')
+  console.log("two");
 }
-one()
+one();
 ```
 The above code will be transformed to the following code, discarding `two()`, as it is never called.
@@ -466,6 +474,7 @@ If these files are side loaded, then `father.js` will be split off into a separa
 - Without code splitting, an import() expression becomes `Promise.resolve().then(() => require())` instead. This still preserves the asynchronous semantics of the expression but it means the imported code is included in the same bundle instead of being split off into a separate file.
 Code splitting is enabled by default. You can disable it by setting the `code_splitting` configuration option to `false` in your application's `/config/application.rb`:
 ```ruby
 config.proscenium.code_splitting = false
 ```
@@ -487,11 +496,11 @@ The new CSS nesting syntax is supported, and transformed into non-nested CSS for
 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.
 ```jsx
-import './button.css'
+import "./button.css";
 export let Button = ({ text }) => {
-  return <div className="button">{text}</div>
-}
+  return <div className="button">{text}</div>;
+};
 ```
 ### CSS Modules
@@ -564,7 +573,7 @@ css_module :my_module_name, path: Rails.root.join('app/components/button.css')
 Importing a CSS module from JS will automatically append the stylesheet to the document's head. And the result of the import will be an object of CSS class to module names.
 ```js
-import styles from './styles.module.css'
+import styles from "./styles.module.css";
 // styles == { header: 'header-5564cdbb' }
 ```
@@ -592,7 +601,7 @@ Use a mixin using the `@mixin` at-rule. Pass it the name of the mixin you want t
 ```css
 // /app/views/layouts/application.css
 p {
-  @mixin bigText from url('/lib/mixins.css');
+  @mixin bigText from url("/lib/mixins.css");
   color: red;
 }
 ```
@@ -640,8 +649,8 @@ There are a few important caveats as far as Typescript is concerned. These are [
 Using JSX syntax usually requires you to manually import the JSX library you are using. For example, if you are using React, by default you will need to import React into each JSX file like this:
 ```javascript
-import * as React from 'react'
-render(<div/>)
+import * as React from "react";
+render(<div />);
 ```
 This is because the JSX transform turns JSX syntax into a call to `React.createElement` but it does not itself import anything, so the React variable is not automatically present.
@@ -655,15 +664,15 @@ In the [not too distant] future, you will be able to configure Proscenium to use
 Importing .json files parses the JSON file into a JavaScript object, and exports the object as the default export. Using it looks something like this:
 ```javascript
-import object from './example.json'
-console.log(object)
+import object from "./example.json";
+console.log(object);
 ```
 In addition to the default export, there are also named exports for each top-level property in the JSON object. Importing a named export directly means Proscenium can automatically remove unused parts of the JSON file from the bundle, leaving only the named exports that you actually used. For example, this code will only include the version field when bundled:
 ```javascript
-import { version } from './package.json'
-console.log(version)
+import { version } from "./package.json";
+console.log(version);
 ```
 ## Phlex Support
@@ -682,14 +691,14 @@ In your layouts, include `Proscenium::Phlex::AssetInclusions`, and call the `inc
 ```ruby
 class ApplicationLayout < Proscenium::Phlex
-  include Proscenium::Phlex::AssetInclusions
+  include Proscenium::Phlex::AssetInclusions # <--
   def template(&)
     doctype
     html do
       head do
         title { 'My Awesome App' }
-        include_assets
+        include_assets # <--
       end
       body(&)
     end
@@ -798,7 +807,7 @@ The view above will be rendered something like this:
 ## Cache Busting
-> *COMING SOON*
+> _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.

data/lib/proscenium/builder.rb CHANGED Viewed

@@ -18,19 +18,34 @@ module Proscenium
       enum :environment, [:development, 1, :test, :production]
-      attach_function :build, [
-        :string,      # path or entry point. multiple can be given by separating with a semi-colon
-        :string,      # base URL of the Rails app. eg. https://example.com
-        :string,      # path to import map, relative to root
+      attach_function :build_to_string, [
+        :string,      # Path or entry point.
+        :string,      # Base URL of the Rails app. eg. https://example.com
+        :string,      # Path to import map, relative to root
         :string,      # ENV variables as a JSON string
         # Config
         :string,      # Rails application root
         :string,      # Proscenium gem root
         :environment, # Rails environment as a Symbol
-        :bool,        # code splitting enabled?
-        :string,      # engine names and paths as a JSON string
-        :bool         # debugging enabled?
+        :bool,        # Code splitting enabled?
+        :string,      # Engine names and paths as a JSON string
+        :bool         # Debugging enabled?
+      ], Result.by_value
+      attach_function :build_to_path, [
+        :string,      # Path or entry point. Multiple can be given by separating with a semi-colon
+        :string,      # Base URL of the Rails app. eg. https://example.com
+        :string,      # Path to import map, relative to root
+        :string,      # ENV variables as a JSON string
+        # Config
+        :string,      # Rails application root
+        :string,      # Proscenium gem root
+        :environment, # Rails environment as a Symbol
+        :bool,        # Code splitting enabled?
+        :string,      # Engine names and paths as a JSON string
+        :bool         # Debugging enabled?
       ], Result.by_value
       attach_function :resolve, [
@@ -68,8 +83,12 @@ module Proscenium
       end
     end
-    def self.build(path, root: nil, base_url: nil)
-      new(root: root, base_url: base_url).build(path)
+    def self.build_to_path(path, root: nil, base_url: nil)
+      new(root: root, base_url: 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)
     end
     def self.resolve(path, root: nil)
@@ -81,15 +100,35 @@ module Proscenium
       @base_url = base_url
     end
-    def build(path) # rubocop:disable Metrics/AbcSize
-      ActiveSupport::Notifications.instrument('build.proscenium', identifier: path) do
-        result = Request.build(path, @base_url, import_map, env_vars.to_json,
-                               @root.to_s,
-                               Pathname.new(__dir__).join('..', '..').to_s,
-                               Rails.env.to_sym,
-                               Proscenium.config.code_splitting,
-                               engines.to_json,
-                               Proscenium.config.debug)
+    def build_to_path(path) # rubocop:disable Metrics/AbcSize
+      ActiveSupport::Notifications.instrument('build_to_path.proscenium',
+                                              identifier: path,
+                                              cached: Proscenium.cache.exist?(path)) do
+        Proscenium.cache.fetch path do
+          result = Request.build_to_path(path, @base_url, import_map, env_vars.to_json,
+                                         @root.to_s,
+                                         gem_root,
+                                         Rails.env.to_sym,
+                                         Proscenium.config.code_splitting,
+                                         engines.to_json,
+                                         Proscenium.config.debug)
+          raise BuildError, result[:response] unless result[:success]
+          result[:response]
+        end
+      end
+    end
+    def build_to_string(path)
+      ActiveSupport::Notifications.instrument('build_to_string.proscenium', identifier: path) do
+        result = Request.build_to_string(path, @base_url, import_map, env_vars.to_json,
+                                         @root.to_s,
+                                         gem_root,
+                                         Rails.env.to_sym,
+                                         Proscenium.config.code_splitting,
+                                         engines.to_json,
+                                         Proscenium.config.debug)
         raise BuildError, result[:response] unless result[:success]
@@ -100,7 +139,7 @@ module Proscenium
     def resolve(path)
       ActiveSupport::Notifications.instrument('resolve.proscenium', identifier: path) do
         result = Request.resolve(path, import_map, @root.to_s,
-                                 Pathname.new(__dir__).join('..', '..').to_s,
+                                 gem_root,
                                  Rails.env.to_sym,
                                  Proscenium.config.debug)
         raise ResolveError.new(path, result[:response]) unless result[:success]
@@ -140,5 +179,9 @@ module Proscenium
       nil
     end
+    def gem_root
+      Pathname.new(__dir__).join('..', '..').to_s
+    end
   end
 end

data/lib/proscenium/css_module/transformer.rb CHANGED Viewed

@@ -69,11 +69,13 @@ module Proscenium
       resolved_path = Resolver.resolve(path.to_s)
       digest = Importer.import(resolved_path)
+      transformed_path = ''
+      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_name[1..]}-#{digest}#{transformed_path}"
                          else
-                           "#{transformed_name}-#{digest}"
+                           "#{transformed_name}-#{digest}#{transformed_path}"
                          end
       [transformed_name, resolved_path]

data/lib/proscenium/ensure_loaded.rb CHANGED Viewed

@@ -9,15 +9,15 @@ module Proscenium
         append_after_action do
           if request.format.html? && Importer.imported?
             if Importer.js_imported?
-              raise NotIncludedError, 'There are javascripts to be included, but they have ' \
-                                      'not been included in the page. Did you forget to add the ' \
-                                      '`#include_javascripts` helper in your views?'
+              raise NotIncludedError, 'There are side loaded javascripts to be included, but ' \
+                                      'they have not been included in the page. Did you forget ' \
+                                      'to add the `#include_assets` helper in your views?'
             end
             if Importer.css_imported?
-              raise NotIncludedError, 'There are stylesheets to be included, but they have ' \
-                                      'not been included in the page. Did you forget to add the ' \
-                                      '`#include_stylesheets` helper in your views?'
+              raise NotIncludedError, 'There are side loaded stylesheets to be included, but ' \
+                                      'they have not been included in the page. Did you forget ' \
+                                      'to add the `#include_assets` helper in your views?'
             end
           end
         end

data/lib/proscenium/ext/proscenium CHANGED Viewed

Binary file

data/lib/proscenium/ext/proscenium.h CHANGED Viewed

@@ -83,6 +83,21 @@ extern "C" {
 #endif
+// Build the given `path` in the `root`.
+//
+//	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?
+//
+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
@@ -97,7 +112,7 @@ extern "C" {
 //	- codeSpitting?
 //	- debug?
 //
-extern struct Result build(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_path(char* filepath, char* baseUrl, char* importMap, char* envVars, char* appRoot, char* gemPath, unsigned int env, GoUint8 codeSplitting, char* engines, GoUint8 debug);
 // Resolve the given `path` relative to the `root`.
 //

data/lib/proscenium/helper.rb CHANGED Viewed

@@ -2,15 +2,23 @@
 module Proscenium
   module Helper
+    def sideload_assets(value)
+      if value.nil?
+        @current_template.instance_variable_defined?(:@sideload_assets_options) &&
+          @current_template.remove_instance_variable(:@sideload_assets_options)
+      else
+        @current_template.instance_variable_set :@sideload_assets_options, value
+      end
+    end
+    # Overriden to allow regular use of javascript_include_tag and stylesheet_link_tag, while still
+    # 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.
     def compute_asset_path(path, options = {})
       if %i[javascript stylesheet].include?(options[:type])
-        result = "/#{path}"
-        if (qs = Proscenium.config.cache_query_string)
-          result << "?#{qs}"
-        end
-        return result
+        result = Proscenium::Builder.build_to_path(path, base_url: request.base_url)
+        return result.split('::').last.delete_prefix 'public'
       end
       super
@@ -40,78 +48,23 @@ module Proscenium
       CssModule::Transformer.new(path).class_names(*names).map { |name, _| name }.join(' ')
     end
-    def include_stylesheets(**options)
-      out = []
-      Importer.each_stylesheet(delete: true) do |path, _path_options|
-        out << stylesheet_link_tag(path, extname: false, **options)
-      end
-      out.join("\n").html_safe
+    def include_assets
+      include_stylesheets + include_javascripts
+    end
+    def include_stylesheets
+      '<!-- [PROSCENIUM_STYLESHEETS] -->'.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.
     #
-    # @param extract_lazy_scripts [Boolean] if true, any lazy scripts will be extracted using
-    #   `content_for` to `:proscenium_lazy_scripts` for later use. Be sure to include this in your
-    #   page with the `declare_lazy_scripts` helper, or simply
-    #   `content_for :proscenium_lazy_scripts`.
     # @return [String] the HTML tags for the javascripts.
-    def include_javascripts(extract_lazy_scripts: false, **options) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      out = []
-      if Rails.application.config.proscenium.code_splitting && Importer.multiple_js_imported?
-        imports = Importer.imported.dup
-        paths_to_build = []
-        Importer.each_javascript(delete: true) do |x, _|
-          paths_to_build << x.delete_prefix('/')
-        end
-        result = Builder.build(paths_to_build.join(';'), base_url: request.base_url)
-        # Remove the react components from the results, so they are not side loaded. Instead they
-        # are lazy loaded by the component manager.
-        scripts = {}
-        result.split(';').each do |x|
-          inpath, outpath = x.split('::')
-          inpath.prepend '/'
-          outpath.delete_prefix! 'public'
-          next unless imports.key?(inpath)
-          if (import = imports[inpath]).delete(:lazy)
-            scripts[inpath] = import.merge(outpath: outpath)
-          else
-            out << javascript_include_tag(outpath, extname: false, **options)
-          end
-        end
-        if extract_lazy_scripts
-          content_for :proscenium_lazy_scripts do
-            tag.script type: 'application/json', id: 'prosceniumLazyScripts' do
-              raw scripts.to_json
-            end
-          end
-        else
-          out << tag.script(type: 'application/json', id: 'prosceniumLazyScripts') do
-            raw scripts.to_json
-          end
-        end
-      else
-        Importer.each_javascript(delete: true) do |path, _|
-          out << javascript_include_tag(path, extname: false, **options)
-        end
-      end
-      out.join("\n").html_safe
+    def include_javascripts
+      '<!-- [PROSCENIUM_LAZY_SCRIPTS] --><!-- [PROSCENIUM_JAVASCRIPTS] -->'.html_safe
     end
     alias side_load_javascripts include_javascripts
     deprecate side_load_javascripts: 'Use `include_javascripts` instead', deprecator: Deprecator.new
-    def declare_lazy_scripts
-      content_for :proscenium_lazy_scripts
-    end
   end
 end