proscenium 0.19.0.beta6-arm64-darwin → 0.19.0.beta8-arm64-darwin

data/lib/proscenium/railtie.rb

@@ -14,42 +14,15 @@ module Proscenium
     config.proscenium.bundle = true
     config.proscenium.side_load = true
     config.proscenium.code_splitting = true
-    config.proscenium.external_node_modules = false
 
-    # Cache asset paths when building to path. Enabled by default in production.
-    # @see Proscenium::Builder#build_to_path
-    config.proscenium.cache = ActiveSupport::Cache::MemoryStore.new if Rails.env.production?
-
-    # TODO: implement!
     config.proscenium.cache_query_string = Rails.env.production? && ENV.fetch('REVISION', nil)
     config.proscenium.cache_max_age = 2_592_000 # 30 days
 
-    # A proc that will be given the path to build, and should return a boolean indicating whether to
-    # cache the response.
-    #
-    # Example:
-    #   cache_middleware_response = ->(path) { path.start_with?('node_modules/') }
-    config.proscenium.cache_middleware_response = nil
-
     # List of environment variable names that should be passed to the builder, which will then be
     # passed to esbuild's `Define` option. Being explicit about which environment variables are
     # defined means a faster build, as esbuild will have less to do.
     config.proscenium.env_vars = Set.new
 
-    # Rails engines to expose and allow Proscenium to serve their assets.
-    #
-    # A Rails engine that has assets, can add Proscenium as a gem dependency, and then add itself
-    # to this list. Proscenium will then serve the engine's assets at the URL path beginning with
-    # the engine name.
-    #
-    # Example:
-    #   class Gem1::Engine < ::Rails::Engine
-    #     config.proscenium.engines[:gem1] = root
-    #   end
-    config.proscenium.engines = {
-      proscenium: Proscenium.ui_path
-    }
-
     config.action_dispatch.rescue_templates = {
       'Proscenium::Builder::BuildError' => 'build_error'
     }

data/lib/proscenium/react_componentable.rb

@@ -46,7 +46,6 @@ module Proscenium
     class_methods do
       def sideload(options)
         Importer.import manager, **options, js: { type: 'module' }
-        Importer.sideload source_path, lazy: true, **options
       end
     end
 

data/lib/proscenium/registry/bundled_package.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rubygems/package'
+
+class Proscenium::Registry
+  class BundledPackage < Package
+    def version = @version ||= spec.version.to_s
+
+    private
+
+    def package_json
+      @package_json ||= begin
+        unless (gem_path = Proscenium::BundledGems.pathname_for(gem_name))
+          raise PackageNotInstalledError, name
+        end
+
+        if (package_path = gem_path.join('package.json')).exist?
+          JSON.parse(package_path.read)
+        else
+          default_package_json
+        end
+      end
+    end
+
+    def spec
+      @spec ||= Bundler.load.specs[gem_name].first
+    end
+  end
+end

data/lib/proscenium/registry/package.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class Proscenium::Registry
+  # 1. Fetch the gem metadata from RubyGems API.
+  # 2. Extract any package.json from the gem, and populate the response with it.
+  # 3. Create a tarball containing the fetched package.json. This will be downloaded by the npm
+  #    client, and unpacked into node_modules. Proscenium ignores this, as it will pull contents
+  #    directly from location of the installed gem.
+  # 4. Return a valid npm response listing package details, tarball location, and its dependencies.
+  #
+  # See https://wiki.commonjs.org/wiki/Packages/Registry
+  class Package
+    extend Literal::Properties
+
+    prop :name, String, :positional, reader: :private
+    prop :version, _String?
+    prop :host, String
+
+    def as_json
+      {
+        name:,
+        'dist-tags': {
+          latest: version
+        },
+        versions: {
+          version => {
+            name:,
+            version:,
+            dependencies: package_json['dependencies'] || {},
+            dist: {
+              tarball:,
+              integrity:,
+              shasum:
+            }
+          }
+        }
+      }
+    end
+
+    def validate!
+      return self if name.start_with?('@rubygems/')
+
+      raise PackageUnsupportedError, name
+    end
+
+    def gem_name = @gem_name ||= name.gsub('@rubygems/', '')
+    def version = @version # rubocop:disable Style/TrivialAccessors
+    def shasum = Digest::SHA1.file(tarball_path).hexdigest
+    def integrity = "sha512-#{Digest::SHA512.file(tarball_path).base64digest}"
+
+    private
+
+    def tarball
+      create_tarball unless tarball_path.exist?
+
+      "#{@host}/#{tarball_path.relative_path_from(Rails.public_path)}"
+    end
+
+    def tarball_name
+      @tarball_name ||= "#{gem_name}-#{version}"
+    end
+
+    def tarball_path
+      @tarball_path ||= Rails.public_path.join('proscenium_registry_tarballs')
+                             .join("@rubygems/#{gem_name}/#{tarball_name}.tgz")
+    end
+
+    def create_tarball
+      FileUtils.mkdir_p(File.dirname(tarball_path))
+
+      File.open(tarball_path, 'wb') do |file|
+        Zlib::GzipWriter.wrap(file) do |gz|
+          Gem::Package::TarWriter.new(gz) do |tar|
+            contents = package_json.to_json
+            tar.add_file_simple('package/package.json', 0o444, contents.length) do |io|
+              io.write contents
+            end
+          end
+        end
+      end
+    end
+
+    def package_json
+      @package_json ||= default_package_json
+    end
+
+    def default_package_json
+      {
+        name:,
+        version:,
+        dependencies: {}
+      }
+    end
+  end
+end

data/lib/proscenium/registry/ruby_gem_package.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Proscenium::Registry
+  class RubyGemPackage < Package
+    def version = spec['version']
+
+    private
+
+    def package_json
+      @package_json ||= begin
+        package_path = Proscenium::RubyGems.path_for(gem_name, version).join('package.json')
+        if package_path.exist?
+          JSON.parse path.read
+        else
+          default_package_json
+        end
+      end
+    end
+
+    def spec
+      @spec ||= if @version.present?
+                  Gems::V2.info gem_name, @version
+                else
+                  Gems.info(gem_name)
+                end
+    end
+  end
+end

data/lib/proscenium/registry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Proscenium::Registry
+  extend ActiveSupport::Autoload
+
+  autoload :Package
+  autoload :BundledPackage
+  autoload :RubyGemPackage
+
+  class PackageUnsupportedError < StandardError
+    def initialize(name)
+      super("Package `#{name}` is not valid; only Ruby gems are supported via the @rubygems scope.")
+    end
+  end
+
+  class PackageNotInstalledError < StandardError
+    def initialize(name)
+      super("Package `#{name}` is not found in your bundle; have you installed the Ruby gem?")
+    end
+  end
+
+  def self.bundled_package(name, host:)
+    BundledPackage.new(name, host:).validate!
+  end
+
+  def self.ruby_gem_package(name, version, host:)
+    RubyGemPackage.new(name, version:, host:).validate!
+  end
+end

data/lib/proscenium/resolver.rb

@@ -4,31 +4,36 @@ require 'active_support/current_attributes'
 
 module Proscenium
   class Resolver < ActiveSupport::CurrentAttributes
-    # TODO: cache this across requests in production.
-    attribute :resolved
+    attribute :resolved unless Rails.env.production?
+    mattr_accessor :resolved if Rails.env.production?
 
-    # Resolve the given `path` to a URL path.
+    # Resolve the given `path` to a fully qualified URL path.
     #
-    # @param path [String] Can be URL path, file system path, or bare specifier (ie. NPM package).
+    # @param path [String] URL path, file system path, or bare specifier (ie. NPM package).
     # @return [String] URL path.
     def self.resolve(path)
       self.resolved ||= {}
 
-      self.resolved[path] ||= begin
-        if path.start_with?('./', '../')
-          raise ArgumentError, 'path must be an absolute file system or URL path'
-        end
-
-        if path.start_with?('proscenium/')
-          "/#{path}"
-        elsif (engine = Proscenium.config.engines.find { |_, v| path.start_with? "#{v}/" })
-          path.sub(/^#{engine.last}/, "/#{engine.first}")
-        elsif path.start_with?("#{Rails.root}/")
-          path.delete_prefix Rails.root.to_s
-        else
-          Builder.resolve path
-        end
+      if path.start_with?('./', '../')
+        raise ArgumentError, '`path` must be an absolute file system or URL path'
       end
+
+      self.resolved[path] ||= if (gem = BundledGems.paths.find { |_, v| path.start_with? "#{v}/" })
+                                # If the path is a rubygem, and it is installed with npm via the
+                                # @rubygems scope, then resolve the path to the symlinked location
+                                # in node_modules.
+                                # npm_path = Rails.root.join("node_modules/@rubygems/#{gem.first}")
+                                # if npm_path.symlink?
+                                #   npm_path.realpath.join(path.sub(/^#{gem.last}/, '.')).to_s
+                                #           .delete_prefix(Rails.root.to_s)
+                                # else
+                                path.sub(/^#{gem.last}/, "/node_modules/@rubygems/#{gem.first}")
+                                # end
+                              elsif path.start_with?("#{Rails.root}/")
+                                path.delete_prefix Rails.root.to_s
+                              else
+                                Builder.resolve path
+                              end
     end
   end
 end

data/lib/proscenium/ruby_gems.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rubygems/package'
+require 'rubygems/remote_fetcher'
+
+module Proscenium
+  class RubyGems
+    def self.path_for(name, version = nil)
+      Pathname new(name, version).path
+    end
+
+    def initialize(name, version = nil)
+      @name = name
+      @version = version
+    end
+
+    def path
+      dependency = Gem::Dependency.new @name, @version
+      path = gem_path dependency
+
+      raise "Gem '#{@name}' not installed nor fetchable." unless path
+
+      basename = File.basename path, '.gem'
+      target_dir = File.expand_path basename, Rails.root.join('tmp', 'unpacked_gems')
+
+      Gem::Package.new(path).extract_files target_dir
+
+      target_dir
+    end
+
+    # Find cached filename in Gem.path. Returns nil if the file cannot be found.
+    def find_in_cache(filename)
+      Gem.path.each do |path|
+        this_path = File.join(path, 'cache', filename)
+        return this_path if File.exist? this_path
+      end
+
+      nil
+    end
+
+    # Return the full path to the cached gem file matching the given
+    # name and version requirement.  Returns 'nil' if no match.
+    #
+    # Example:
+    #
+    #   get_path 'rake', '> 0.4' # "/usr/lib/ruby/gems/1.8/cache/rake-0.4.2.gem"
+    #   get_path 'rake', '< 0.1' # nil
+    #   get_path 'rak'           # nil (exact name required)
+    def gem_path(dependency)
+      return dependency.name if /\.gem$/i.match?(dependency.name)
+
+      specs = dependency.matching_specs
+      selected = specs.max_by(&:version)
+
+      return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless selected
+      return unless /^#{selected.name}$/i.match?(dependency.name)
+
+      # We expect to find (basename).gem in the 'cache' directory. Furthermore,
+      # the name match must be exact (ignoring case).
+      path = find_in_cache File.basename selected.cache_file
+
+      return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless path
+
+      path
+    end
+  end
+end

data/lib/proscenium/side_load.rb

@@ -4,7 +4,6 @@ module Proscenium
   class SideLoad
     JS_COMMENT = '<!-- [PROSCENIUM_JAVASCRIPTS] -->'
     CSS_COMMENT = '<!-- [PROSCENIUM_STYLESHEETS] -->'
-    LAZY_COMMENT = '<!-- [PROSCENIUM_LAZY_SCRIPTS] -->'
 
     module Controller
       def self.included(child)
@@ -35,28 +34,16 @@ module Proscenium
 
         return if !fragments && !included_comment
 
-        imports = Proscenium::Importer.imported.dup
-        paths_to_build = []
-        Proscenium::Importer.each_stylesheet(delete: true) do |x, _|
-          paths_to_build << x.delete_prefix('/')
-        end
-
-        result = Proscenium::Builder.build_to_path(paths_to_build.join(';'))
-
         out = []
-        result.split(';').each do |x|
-          inpath, outpath = x.split('::')
-          inpath.prepend '/'
-          outpath.delete_prefix! 'public'
-
-          next unless imports.key?(inpath)
-
-          import = imports[inpath]
-          opts = import[:css].is_a?(Hash) ? import[:css] : {}
+        Proscenium::Importer.each_stylesheet(delete: true) do |path, opts|
+          opts = opts[:css].is_a?(Hash) ? opts[:css] : {}
           opts[:preload_links_header] = false if fragments
           opts[:data] ||= {}
-          opts[:data][:original_href] = inpath
-          out << helpers.stylesheet_link_tag(outpath, extname: false, **opts)
+
+          if Proscenium.config.cache_query_string.present?
+            path += "?#{Proscenium.config.cache_query_string}"
+          end
+          out << helpers.stylesheet_link_tag(path, extname: false, **opts)
         end
 
         if fragments
@@ -70,72 +57,43 @@ module Proscenium
         return if response_body.nil?
         return if response_body.first.blank? || !Proscenium::Importer.js_imported?
 
-        imports = Proscenium::Importer.imported.dup
-        paths_to_build = []
-        Proscenium::Importer.each_javascript(delete: true) do |x, _|
-          paths_to_build << x.delete_prefix('/')
-        end
-
-        result = Proscenium::Builder.build_to_path(paths_to_build.join(';'))
-
-        included_js_comment = response_body.first.include?(JS_COMMENT)
-        included_lazy_comment = response_body.first.include?(LAZY_COMMENT)
+        included_comment = response_body.first.include?(JS_COMMENT)
         fragments = if (fragment_header = request.headers['X-Fragment'])
                       fragment_header.split
                     end
 
-        if fragments || included_js_comment
-          out = []
-          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:)
-            else
-              opts = import[:js].is_a?(Hash) ? import[:js] : {}
-              opts[:preload_links_header] = false if fragments
-              out << helpers.javascript_include_tag(outpath, extname: false, **opts)
-            end
-          end
+        return if !fragments && !included_comment
 
-          if fragments
-            response_body.first.prepend out.join.html_safe
-          elsif included_js_comment
-            response_body.first.gsub! JS_COMMENT, out.join.html_safe
-          end
-        end
+        out = []
+        Proscenium::Importer.each_javascript(delete: true) do |path, opts|
+          next if opts.delete(:lazy)
 
-        return if !fragments && !included_lazy_comment
+          opts = opts[:js].is_a?(Hash) ? opts[:js] : {}
+          opts[:preload_links_header] = false if fragments
 
-        lazy_script = ''
-        if scripts.present?
-          lazy_script = helpers.content_tag 'script', type: 'application/json',
-                                                      id: 'prosceniumLazyScripts' do
-            scripts.to_json.html_safe
+          if Proscenium.config.cache_query_string.present?
+            path += "?#{Proscenium.config.cache_query_string}"
           end
+          out << helpers.javascript_include_tag(path, extname: false, **opts)
         end
 
         if fragments
-          response_body.first.prepend lazy_script
-        elsif included_lazy_comment
-          response_body.first.gsub! LAZY_COMMENT, lazy_script
+          response_body.first.prepend out.join.html_safe
+        elsif included_comment
+          response_body.first.gsub! JS_COMMENT, out.join.html_safe
         end
       end
     end
 
     class << self
-      # Side loads the class, and its super classes that respond to `.source_path`.
+      # Side loads assets for the class, and its super classes that respond to `.source_path`, which
+      # should return a Pathname of the class source file.
       #
       # Set the `abstract_class` class variable to true in any class, and it will not be side
       # loaded.
       #
-      # If the class responds to `.sideload`, it will be called instead of the regular side loading.
-      # You can use this to customise what is side loaded.
+      # If the class responds to `.sideload`, it will be called after the regular side loading. You
+      # can use this to customise what is side loaded.
       def sideload_inheritance_chain(obj, options)
         return unless Proscenium.config.side_load
 
@@ -159,18 +117,28 @@ module Proscenium
 
         klass = obj.class
         while klass.respond_to?(:source_path) && klass.source_path && !klass.abstract_class
-          if klass.respond_to?(:sideload)
-            klass.sideload options
-          elsif options[:css] == false
+          if options[:css] == false
             Importer.sideload klass.source_path, **options
           else
             Importer.sideload_js klass.source_path, **options
             css_imports << klass.source_path
           end
 
+          klass.sideload options if klass.respond_to?(:sideload)
+
           klass = klass.superclass
         end
 
+        # All regular CSS files (*.css) are ancestrally sideloaded. However, the first CSS module
+        # 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|
+          break if Importer.sideload_css_module(it, **options).present?
+        end
+
+        # Sideload regular CSS files in reverse order.
+        #
         # 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.

data/lib/proscenium/ui/flash/bun.lock

@@ -0,0 +1,19 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@proscenium/flash",
+      "dependencies": {
+        "dom-mutations": "^1.0.0",
+      },
+      "devDependencies": {
+        "sourdough-toast": "latest",
+      },
+    },
+  },
+  "packages": {
+    "dom-mutations": ["dom-mutations@1.0.0", "", {}, "sha512-qr4ufk/qu+JKwtz7NPbu6TxpTM/7nqburohI07J+mKSM20USvhcUjEb8hWY6g2a3QYp3LtlGpi+mAZLPuxTi7g=="],
+
+    "sourdough-toast": ["sourdough-toast@0.1.0", "", {}, "sha512-ianhWqaaA5a0n9TRg6dLEt5DWflXqsQUMxEAGZi8JcHGqsPRm7XTWEfhhDKSi/zJ11CBbvh8b8oRcgxjCeYZeg=="],
+  }
+}

data/lib/proscenium/ui/flash/index.js

@@ -1,5 +1,9 @@
-import domMutations from "https://esm.run/dom-mutations";
-import { Sourdough, toast } from "https://esm.run/sourdough-toast";
+import domMutations from "dom-mutations";
+import { Sourdough, toast } from "sourdough-toast";
+
+export function foo() {
+  console.log("foo");
+}
 
 class HueFlash extends HTMLElement {
   static observedAttributes = ["data-flash-alert", "data-flash-notice"];

data/lib/proscenium/ui/flash/node_modules/dom-mutations/index.d.ts

@@ -0,0 +1,33 @@
+export type Options = MutationObserverInit & {signal?: AbortSignal};
+
+/**
+@returns An async iterable that yields [`MutationRecord`](https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord) objects representing individual mutations.
+
+@example
+```
+import domMutations from 'dom-mutations';
+
+const target = document.querySelector('#unicorn');
+
+for await (const mutation of domMutations(target, {childList: true})) {
+	console.log('Mutation:', mutation);
+}
+```
+*/
+export default function domMutations(target: Node, options?: Options): AsyncIterable<MutationRecord>;
+
+/**
+Similar to `domMutations()`, but yields batches of [`MutationRecord`](https://developer.mozilla.org/en-US/docs/Web/API/MutationRecord) objects, each batch representing a group of mutations captured together. This method is less convenient, but can be useful in some cases when you need to handle mutations together as a group.
+
+@example
+```
+import {batchedDomMutations} from 'dom-mutations';
+
+const target = document.querySelector('#unicorn');
+
+for await (const mutations of batchedDomMutations(target, {childList: true})) {
+	console.log('Batch of mutations:', mutations);
+}
+```
+*/
+export function batchedDomMutations(target: Node, options?: Options): AsyncIterable<MutationRecord[]>;

data/lib/proscenium/ui/flash/node_modules/dom-mutations/index.js

@@ -0,0 +1,44 @@
+export default function domMutations(target, options = {}) {
+	return {
+		async * [Symbol.asyncIterator]() {
+			for await (const mutations of batchedDomMutations(target, options)) {
+				yield * mutations;
+			}
+		},
+	};
+}
+
+export function batchedDomMutations(target, {signal, ...options} = {}) {
+	return {
+		async * [Symbol.asyncIterator]() {
+			signal?.throwIfAborted();
+
+			let resolveMutations;
+			let rejectMutations;
+
+			const observer = new globalThis.MutationObserver(mutations => {
+				resolveMutations?.(mutations);
+			});
+
+			observer.observe(target, options);
+
+			signal?.addEventListener('abort', () => {
+				rejectMutations?.(signal.reason);
+				observer.disconnect();
+			}, {once: true});
+
+			try {
+				while (true) {
+					signal?.throwIfAborted();
+
+					yield await new Promise((resolve, reject) => { // eslint-disable-line no-await-in-loop
+						resolveMutations = resolve;
+						rejectMutations = reject;
+					});
+				}
+			} finally {
+				observer.disconnect();
+			}
+		},
+	};
+}

data/lib/proscenium/ui/flash/node_modules/dom-mutations/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.