proscenium 0.22.0.beta2-x86_64-linux → 0.22.0.beta3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0676f0370ca3f4ee432b27550a798ba203111170b6985458e8fad28002c93b7
-  data.tar.gz: 57ba3c548fae842fa107c1d06f2d5a37037aeae799b2c86896c35d9ba4de0701
+  metadata.gz: c361f5c69260d3dea1620432c797ddab37101f3ff51d046ce21fbddc0105b65a
+  data.tar.gz: cce30ee6481e16c6ebbe53959717214f6eedda804cac3d6e84f374ed117fb644
 SHA512:
-  metadata.gz: d1cb772d5f1d227d51b24abbad01732bd164fbe1699f984ac76c5c31fe0bbeac93229e02e44ead1371653d0cc0ed16e95e2a1334d752768595673496b4e57c57
-  data.tar.gz: aeb301fb4862a552a37e37a282fb956c9d70cdecae6031b94458de2389d9a2fc1070520a7e5e52454a97aa9399b0bd7f55a67cc8b894a2ce7bb62622bdb3953f
+  metadata.gz: e789f3b974d80aa9d087e1a4b33455a1d0e3f7c175c49301e0a19770df788c25ec2ab502079fc26198578d97da0e3ea9ceb2bf52cae4eed4988444be3007e1e4
+  data.tar.gz: b07424e2ba41a0d92c427316ba845f4f3e39fc65942b8e91e9807cb4a70c04435d8b93d8b59c4aa929fbdca9e4fbc04aa95ff8ce0fdfdb34686a01e495acff76

data/README.md

@@ -18,7 +18,6 @@
 - Deep integration with Rails.
 - 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.
 - Source maps.
 
@@ -30,7 +29,6 @@
 - [Side Loading](#side-loading)
 - [Importing](#importing-assets)
   - [Local Imports](#local-imports)
-- [Import Maps](#import-maps)
 - [Source Maps](#source-maps)
 - [SVG](#svg)
 - [Environment Variables](#environment-variables)
@@ -48,9 +46,9 @@
   - [Typescript Caveats](#typescript-caveats)
 - [JSX](#jsx)
 - [JSON](#json)
-- [Cache Busting](#cache-busting)
 - [rjs is back!](#rjs-is-back)
 - [Resolution](#resolution)
+- [Pre-compilation](#precompilation)
 - [Thanks](#thanks)
 - [Development](#development)
 
@@ -258,13 +256,11 @@ Sometimes you don't want to bundle an import. For example, you want to ensure th
 import React from "react" with { unbundle: 'true' };
 ```
 
-You can also unbundle entries in your [import map](#import-maps) using an `unbundle:` prefix, which ensures that all imports of a particular path are always unbundled:
+You can also unbundle entries in [`aliases`](#aliases) using an `unbundle:` prefix, which ensures that all imports of a particular path are always unbundled:
 
-```json
-{
-  "imports": {
-    "react": "unbundle:react"
-  }
+```ruby
+config.proscenium.aliases = {
+  "react": "unbundle:react"
 }
 ```
 
@@ -282,55 +278,6 @@ config.proscenium.bundle = false
 
 This will mean every asset and import will be loaded independently.
 
-## Import Maps
-
-> **[WIP]**
-
-[Import maps](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap) for both JS and CSS is supported out of the box, and works with no regard to the browser being used. This is because the import map is parsed and resolved by Proscenium on the server, instead of by the browser. This is faster, and also allows you to use import maps in browsers that do not support them yet.
-
-If you are not familiar with import maps, think of them as a way to define aliases.
-
-Just create `config/import_map.json` and specify the imports you want to use. For example:
-
-```json
-{
-  "imports": {
-    "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/"
-  }
-}
-```
-
-Using the above import map, we can do...
-
-```js
-import { useCallback } from "react";
-import startHere from "start";
-import styles from "common";
-```
-
-and for CSS...
-
-```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) => ({
-  imports: {
-    react:
-      env === "development"
-        ? "https://esm.sh/react@18.2.0?dev"
-        : "https://esm.sh/react@18.2.0",
-  },
-});
-```
-
 ## Source Maps
 
 Source maps can make it easier to debug your code. They encode the information necessary to translate from a line/column offset in a generated output file back to a line/column offset in the corresponding original input file. This is useful if your generated code is sufficiently different from your original code (e.g. your original code is TypeScript or you enabled minification). This is also useful if you prefer looking at individual files in your browser's developer tools instead of one big bundled file.
@@ -692,26 +639,6 @@ import { version } from "./package.json";
 console.log(version);
 ```
 
-## Cache Busting
-
-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`.
-
-It is assumed that the `REVISION` env var will be unique between deploys. If it isn't, then assets will continue to be cached as the same version between deploys. I recommend you assign a version number or to use the Git commit hash of the deploy. Just make sure it is unique for each deploy.
-
-You can set the `cache_query_string` config option directly to define any query string you wish:
-
-```ruby
-Rails.application.config.proscenium.cache_query_string = 'my-cache-busting-version-string'
-```
-
-The cache is set with a `max-age` of 30 days. You can customise this with the `cache_max_age` config option:
-
-```ruby
-Rails.application.config.proscenium.cache_max_age = 12.months.to_i
-```
-
 ## rjs is back
 
 Proscenium brings back RJS! Any path ending in .rjs will be served from your Rails app. This allows you to import server rendered javascript.
@@ -726,6 +653,28 @@ You can continue to access any file in the `/public` directory as you normally w
 
 If requesting a file that exists in a root directory and the public directory, the file in the public directory will be served. For example, if you have a file at `/lib/foo.js` and `/public/lib/foo.js`, and you request `/lib/foo.js`, the file in the public directory (`/public/lib/foo.js`) will be served.
 
+## Pre-compilation
+
+Proscenium is designed to bundle and minify your frontend code in real time, on demand, with no build step or pre-compilation needed. However, if you want to pre-compile your assets for production deployment, you can do so using the `assets:precompile` Rake task.
+
+```bash
+rails assets:precompile
+```
+
+Be sure to specify a `Set` of paths which you want to pre-compile via the `config.proscenium.precompile` configuration option. Each path should be a glob pattern that matches the files which are your entry points. Don't include paths that are not entry points. For example:
+
+```ruby
+Rails.configuration.proscenium.precompile = Set[
+  "./app/components/**/*.js",
+  "./app/components/**/*.jsx",
+  "./app/views/**/*.js",
+  "./app/views/**/*.css",
+  "./app/views/**/*.module.css"
+]
+```
+
+This will bundle, code split, tree shake, and compile all your JS, TS, JSX, TSX and CSS files and place them in the `public/assets` directory, ready to be served in production.
+
 ## Thanks
 
 HUGE thanks 🙏 go to [Evan Wallace](https://github.com/evanw) and his amazing [esbuild](https://esbuild.github.io/) project. Proscenium would not be possible without it, and it is esbuild that makes this so fast and efficient.

data/lib/proscenium/builder.rb

@@ -26,7 +26,6 @@ module Proscenium
 
       attach_function :build_to_string, [
         :string, # Path or entry point.
-        :string, # cache_query_string.
         :pointer # Config as JSON.
       ], Result.by_value
 
@@ -68,8 +67,8 @@ module Proscenium
       end
     end
 
-    def self.build_to_string(path, cache_query_string: '', root: nil)
-      new(root:).build_to_string(path, cache_query_string:)
+    def self.build_to_string(path, root: nil)
+      new(root:).build_to_string(path)
     end
 
     def self.resolve(path, root: nil)
@@ -97,14 +96,13 @@ module Proscenium
         Bundle: Proscenium.config.bundle,
         Aliases: Proscenium.config.aliases,
         Precompile: Proscenium.config.precompile,
-        QueryString: Proscenium.config.cache_query_string.presence || '',
         Debug: Proscenium.config.debug
       }.to_json)
     end
 
-    def build_to_string(path, cache_query_string: '')
+    def build_to_string(path)
       ActiveSupport::Notifications.instrument('build.proscenium', identifier: path) do
-        result = Request.build_to_string(path, cache_query_string, @request_config)
+        result = Request.build_to_string(path, @request_config)
 
         raise BuildError.new(path, result[:response]) unless result[:success]
 

data/lib/proscenium/ext/proscenium.h

@@ -92,10 +92,9 @@ extern void reset_config();
 // Build the given `path` using the `config`.
 //
 // - path - The path to build relative to `root`.
-// - cache_query_string - The current query string used for cache busting, taken from the URL.
 // - config
 //
-extern struct Result build_to_string(char* filePath, char* cacheQueryString, char* configJson);
+extern struct Result build_to_string(char* filePath, char* configJson);
 
 // Resolve the given `path` relative to the `root`.
 //

data/lib/proscenium/middleware/base.rb

@@ -28,17 +28,6 @@ module Proscenium
         @path_to_build ||= @request.path[1..]
       end
 
-      def cache_query_string
-        @cache_query_string ||= begin
-          params = @request.query_parameters
-          if params.one? && params.first[0] != '' && params.first[1].nil?
-            params.keys.first
-          else
-            Proscenium.config.cache_query_string
-          end
-        end.presence || ''
-      end
-
       def sourcemap?
         @request.path.ends_with?('.map')
       end
@@ -85,10 +74,6 @@ module Proscenium
         response.content_type = content_type
         response.etag = result[:content_hash]
 
-        if !cache_query_string.blank? && Proscenium.config.cache_max_age
-          response.cache! Proscenium.config.cache_max_age
-        end
-
         if @request.fresh?(response)
           response.status = 304
           response.body = []

data/lib/proscenium/middleware/esbuild.rb

@@ -4,7 +4,7 @@ module Proscenium
   class Middleware
     class Esbuild < Base
       def attempt
-        render_response Builder.build_to_string(path_to_build, cache_query_string:)
+        render_response Builder.build_to_string(path_to_build)
       end
     end
   end

data/lib/proscenium/middleware.rb

@@ -20,13 +20,10 @@ module Proscenium
 
       return @app.call(env) if !request.get? && !request.head?
 
-      # If this is a request for an asset chunk, we want to serve it with a very long
-      # cache lifetime, since these are content-hashed and will never change.
       if request.path.match?(CHUNKS_PATH)
         ::ActionDispatch::FileHandler.new(
           Proscenium.config.output_path.to_s,
           headers: {
-            'Cache-Control' => "public, max-age=#{100.years}, immutable",
             'etag' => request.path.match(/-\$([a-z0-9]+)\$/i)[1]
           }
         ).attempt(env) || @app.call(env)

data/lib/proscenium/railtie.rb

@@ -15,8 +15,6 @@ module Proscenium
     config.proscenium.side_load = true
     config.proscenium.code_splitting = true
     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
     config.proscenium.aliases = {}
     config.proscenium.precompile = Set.new
     config.proscenium.output_dir = '/assets'
@@ -56,7 +54,15 @@ module Proscenium
       unless config.proscenium.logging
         app.middleware.insert_before Rails::Rack::Logger, Proscenium::Middleware::SilenceRequest
       end
-      app.middleware.insert_before ActionDispatch::Callbacks, Proscenium::Middleware
+
+      # Ensure the middleware is inserted as early as possible.
+      if app.config.consider_all_requests_local
+        app.middleware.insert_before ActionDispatch::ActionableExceptions, Proscenium::Middleware
+      elsif app.config.reloading_enabled?
+        app.middleware.insert_before ActionDispatch::Reloader, Proscenium::Middleware
+      else
+        app.middleware.insert_before ActionDispatch::Callbacks, Proscenium::Middleware
+      end
     end
 
     initializer 'proscenium.sideloading' do

data/lib/proscenium/side_load.rb

@@ -40,9 +40,6 @@ module Proscenium
           opts[:preload_links_header] = false if fragments
           opts[:data] ||= {}
 
-          if Proscenium.config.cache_query_string.present?
-            path += "?#{Proscenium.config.cache_query_string}"
-          end
           out << helpers.stylesheet_link_tag(path.delete_prefix('/'), extname: false, **opts)
         end
 
@@ -71,9 +68,6 @@ module Proscenium
           opts = opts[:js].is_a?(Hash) ? opts[:js] : {}
           opts[:preload_links_header] = false if fragments
 
-          if Proscenium.config.cache_query_string.present?
-            path += "?#{Proscenium.config.cache_query_string}"
-          end
           out << helpers.javascript_include_tag(path.delete_prefix('/'), extname: false, **opts)
         end
 

data/lib/proscenium/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Proscenium
-  VERSION = '0.22.0.beta2'
+  VERSION = '0.22.0.beta3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: proscenium
 version: !ruby/object:Gem::Version
-  version: 0.22.0.beta2
+  version: 0.22.0.beta3
 platform: x86_64-linux
 authors:
 - Joel Moss