proscenium 0.19.0.beta6 → 0.19.0.beta7

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,60 +57,30 @@ 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

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.

data/lib/proscenium/ui/flash/node_modules/dom-mutations/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "dom-mutations",
+	"version": "1.0.0",
+	"description": "Observe changes to the DOM using an async iterable — A nicer API for MutationObserver",
+	"license": "MIT",
+	"repository": "sindresorhus/dom-mutations",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"test": "xo && ava"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"mutationobserver",
+		"mutation",
+		"mutations",
+		"observer",
+		"observe",
+		"dom",
+		"document",
+		"node",
+		"element",
+		"html",
+		"changes",
+		"asynciterable",
+		"asynciterator",
+		"iterable",
+		"iterator",
+		"generator",
+		"async",
+		"events",
+		"stream",
+		"loop"
+	],
+	"devDependencies": {
+		"ava": "^5.3.1",
+		"jsdom": "^24.1.1",
+		"xo": "^0.59.3"
+	},
+	"ava": {
+		"serial": true
+	}
+}