vite_ruby 3.11.0 → 4.0.0.alpha1

data/lib/vite_ruby/dev_server_proxy.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "rack/proxy"
+require 'rack/proxy'
 
 # Public: Allows to relay asset requests to the Vite development server.
 class ViteRuby::DevServerProxy < Rack::Proxy
   HOST_WITH_PORT_REGEX = %r{^(.+?)(:\d+)/}
-  VITE_DEPENDENCY_PREFIX = "/@"
+  VITE_DEPENDENCY_PREFIX = '/@'
 
   def initialize(app = nil, options = {})
     @vite_ruby = options.delete(:vite_ruby) || ViteRuby.instance
-    options[:streaming] = false if config.mode == "test" && !options.key?(:streaming)
+    options[:streaming] = false if config.mode == 'test' && !options.key?(:streaming)
     super
   end
 
@@ -17,7 +17,7 @@ class ViteRuby::DevServerProxy < Rack::Proxy
   def perform_request(env)
     if vite_should_handle?(env) && dev_server_running?
       forward_to_vite_dev_server(env)
-      super
+      super(env)
     else
       @app.call(env)
     end
@@ -30,48 +30,41 @@ private
   def_delegators :@vite_ruby, :config, :dev_server_running?
 
   def rewrite_uri_for_vite(env)
-    uri = env.fetch("REQUEST_URI") { [env["PATH_INFO"], env["QUERY_STRING"]].reject { |str| str.to_s.strip.empty? }.join("?") }
-    env["PATH_INFO"], env["QUERY_STRING"] = (env["REQUEST_URI"] = normalize_uri(uri)).split("?")
+    uri = env.fetch('REQUEST_URI') { [env['PATH_INFO'], env['QUERY_STRING']].reject { |str| str.to_s.strip.empty? }.join('?') }
+    env['PATH_INFO'], env['QUERY_STRING'] = (env['REQUEST_URI'] = normalize_uri(uri)).split('?')
   end
 
   def normalize_uri(uri)
     uri
-      .sub(HOST_WITH_PORT_REGEX, "/") # Hanami adds the host and port.
-      .sub(".ts.js", ".ts") # Hanami's javascript helper always adds the extension.
-      .sub(/\.(sass|scss|styl|stylus|less|pcss|postcss)\.css$/, '.\1') # Rails' stylesheet_link_tag always adds the extension.
+      .sub(HOST_WITH_PORT_REGEX, '/') # Hanami adds the host and port.
+      .sub('.ts.js', '.ts') # Hanami's javascript helper always adds the extension.
+      .sub(/(\.(?!min|module)\w+)\.css$/, '\1') # Rails' stylesheet_link_tag always adds the extension.
   end
 
   def forward_to_vite_dev_server(env)
     rewrite_uri_for_vite(env)
-    env["QUERY_STRING"] ||= ""
-    env["rack.backend"] = URI(config.origin)
-    env["HTTP_HOST"] = env["HTTP_X_FORWARDED_HOST"] = config.host
-    env["HTTP_X_FORWARDED_SERVER"] = config.host_with_port
-    env["HTTP_PORT"] = env["HTTP_X_FORWARDED_PORT"] = config.port.to_s
-    env["HTTP_X_FORWARDED_PROTO"] = env["HTTP_X_FORWARDED_SCHEME"] = config.protocol
-    env["HTTPS"] = env["HTTP_X_FORWARDED_SSL"] = "off" unless config.https
-    env["SCRIPT_NAME"] = ""
+    env['QUERY_STRING'] ||= ''
+    env['HTTP_HOST'] = env['HTTP_X_FORWARDED_HOST'] = config.host
+    env['HTTP_X_FORWARDED_SERVER'] = config.host_with_port
+    env['HTTP_PORT'] = env['HTTP_X_FORWARDED_PORT'] = config.port.to_s
+    env['HTTP_X_FORWARDED_PROTO'] = env['HTTP_X_FORWARDED_SCHEME'] = config.protocol
+    env['HTTPS'] = env['HTTP_X_FORWARDED_SSL'] = 'off' unless config.https
+    env['SCRIPT_NAME'] = ''
   end
 
   def vite_should_handle?(env)
-    path = normalize_uri(env["PATH_INFO"])
-    return true if path.start_with?(vite_url_prefix) # Vite asset
-
-    true if file_in_vite_root?(path) # Fallback if Vite can serve the file
+    path = normalize_uri(env['PATH_INFO'])
+    return true if path.start_with?(vite_asset_url_prefix) # Vite asset
+    return true if path.start_with?(VITE_DEPENDENCY_PREFIX) # Packages and imports
+    return true if file_in_vite_root?(path) # Fallback if Vite can serve the file
   end
 
-  # NOTE: When using an empty 'public_output_dir', we need to rely on a
-  # filesystem check to check whether Vite should serve the request.
   def file_in_vite_root?(path)
-    path.include?(".") && # Check for extension, avoid filesystem if possible.
-      config.vite_root_dir.join(path.start_with?("/") ? path[1..] : path).file?
+    path.include?('.') && # Check for extension, avoid filesystem if possible.
+      config.vite_root_dir.join(path.start_with?('/') ? path[1..-1] : path).file?
   end
 
-  # NOTE: Vite is configured to use 'public_output_dir' as the base, which can
-  # be customized by the user in development to not match any of the routes.
-  #
-  # If the path starts with that prefix, it will be redirected to Vite.
-  def vite_url_prefix
-    @vite_url_prefix ||= config.public_output_dir.empty? ? VITE_DEPENDENCY_PREFIX : "/#{config.public_output_dir}/"
+  def vite_asset_url_prefix
+    @vite_asset_url_prefix ||= config.public_output_dir.empty? ? "\0" : "/#{ config.public_output_dir }/"
   end
 end

data/lib/vite_ruby/error.rb

@@ -3,7 +3,7 @@
 # Internal: Provides common functionality for errors.
 class ViteRuby::Error < StandardError
   def message
-    super.sub(":troubleshooting:", <<~MSG)
+    super.sub(':troubleshooting:', <<~MSG)
       Visit the Troubleshooting guide for more information:
         https://vite-ruby.netlify.app/guide/troubleshooting.html#troubleshooting
     MSG

data/lib/vite_ruby/io.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require "open3"
+require 'open3'
 
 # Public: Builds on top of Ruby I/O open3 providing a friendlier experience.
 module ViteRuby::IO
   class << self
     # Internal: A modified version of capture3 that can continuosly print stdout.
     # NOTE: Streaming output provides a better UX when running bin/vite build.
-    def capture(*cmd, with_output: $stdout.method(:puts), stdin_data: "", **opts)
+    def capture(*cmd, with_output: $stdout.method(:puts), stdin_data: '', **opts)
       return Open3.capture3(*cmd, **opts) unless with_output
 
       Open3.popen3(*cmd, **opts) { |stdin, stdout, stderr, wait_threads|
@@ -15,13 +15,13 @@ module ViteRuby::IO
         stdin.close
         out = Thread.new { read_lines(stdout, &with_output) }
         err = Thread.new { stderr.read }
-        [out.value, err.value.to_s, wait_threads.value]
+        [out.value, err.value, wait_threads.value]
       }
     end
 
     # Internal: Reads and yield every line in the stream. Returns the full content.
     def read_lines(io)
-      buffer = +""
+      buffer = +''
       while line = io.gets
         buffer << line
         yield line

data/lib/vite_ruby/manifest.rb

@@ -7,7 +7,7 @@
 #   lookup_entrypoint('calendar', type: :javascript)
 #   => { "file" => "/vite/assets/calendar-1016838bab065ae1e314.js", "imports" => [] }
 #
-# NOTE: Using `"autoBuild": true` in `config/vite.json` file will trigger a build
+# NOTE: Using "autoBuild": true` in `config/vite.json` file will trigger a build
 # on demand as needed, before performing any lookup.
 class ViteRuby::Manifest
   def initialize(vite_ruby)
@@ -19,37 +19,19 @@ class ViteRuby::Manifest
   #
   # Raises an error if the resource could not be found in the manifest.
   def path_for(name, **options)
-    lookup!(name, **options).fetch("file")
+    lookup!(name, **options).fetch('file')
   end
 
-  # Internal: Recursively collects all imported chunks for a given entry.
-  # Returns chunks in dependency-first order (deepest imports first), deduped.
-  def import_chunks_for(entry, seen_filenames: Set.new)
-    chunks = []
-
-    entry["imports"]&.each do |chunk|
-      filename = chunk["file"]
-      next if seen_filenames.include?(filename)
-      seen_filenames.add(filename)
-
-      chunks.concat(import_chunks_for(chunk, seen_filenames: seen_filenames))
-      chunks << chunk
-    end
-
-    chunks
-  end
-
-  # Public: Returns scripts, imported modules, and stylesheets for the specified
+  # Public: Returns entries, imported modules, and stylesheets for the specified
   # entrypoint files.
   def resolve_entries(*names, **options)
     entries = names.map { |name| lookup!(name, **options) }
-    script_paths = entries.map { |entry| entry.fetch("file") }
 
-    imports = dev_server_running? ? [] : entries.flat_map { |entry| import_chunks_for(entry) }
+    imports = dev_server_running? ? [] : entries.flat_map { |entry| entry['imports'] }.compact.uniq
     {
-      scripts: script_paths,
-      imports: imports.filter_map { |entry| entry.fetch("file") }.uniq,
-      stylesheets: dev_server_running? ? [] : (entries + imports).flat_map { |entry| entry["css"] }.compact.uniq,
+      main: entries.map(&TO_ENTRY),
+      imports: imports.map(&TO_ENTRY).uniq,
+      stylesheets: dev_server_running? ? [] : (entries + imports).flat_map { |entry| entry['css'] }.compact.uniq,
     }
   end
 
@@ -60,7 +42,7 @@ class ViteRuby::Manifest
 
   # Public: The path from where the browser can download the Vite HMR client.
   def vite_client_src
-    prefix_asset_with_host("@vite/client") if dev_server_running?
+    prefix_asset_with_host('@vite/client') if dev_server_running?
   end
 
   # Public: The content of the preamble needed by the React Refresh plugin.
@@ -68,27 +50,21 @@ class ViteRuby::Manifest
     if dev_server_running?
       <<~REACT_REFRESH
         <script type="module">
-          #{react_preamble_code}
+          import RefreshRuntime from '#{ prefix_asset_with_host('@react-refresh') }'
+          RefreshRuntime.injectIntoGlobalHook(window)
+          window.$RefreshReg$ = () => {}
+          window.$RefreshSig$ = () => (type) => type
+          window.__vite_plugin_react_preamble_installed__ = true
         </script>
       REACT_REFRESH
     end
   end
 
-  # Public: Source script for the React Refresh plugin.
-  def react_preamble_code
-    if dev_server_running?
-      <<~REACT_PREAMBLE_CODE
-        import RefreshRuntime from '#{prefix_asset_with_host("@react-refresh")}'
-        RefreshRuntime.injectIntoGlobalHook(window)
-        window.$RefreshReg$ = () => {}
-        window.$RefreshSig$ = () => (type) => type
-        window.__vite_plugin_react_preamble_installed__ = true
-      REACT_PREAMBLE_CODE
-    end
-  end
-
 protected
 
+  # Internal: Returns a [src, attrs] entry.
+  TO_ENTRY = ->(entry) { [entry.fetch('file'), entry.slice('integrity').symbolize_keys] }
+
   # Internal: Strict version of lookup.
   #
   # Returns a relative path for the asset, or raises an error if not found.
@@ -104,7 +80,7 @@ protected
   #   manifest.lookup('calendar.js')
   #   => { "file" => "/vite/assets/calendar-1016838bab065ae1e122.js", "imports" => [] }
   def lookup(name, **options)
-    @build_mutex.synchronize { builder.build || (return nil) } if should_build?
+    @build_mutex.synchronize { builder.build } if should_build?
 
     find_manifest_entry resolve_entry_name(name, **options)
   end
@@ -112,7 +88,7 @@ protected
 private
 
   # Internal: The prefix used by Vite.js to request files with an absolute path.
-  FS_PREFIX = "/@fs/"
+  FS_PREFIX = '/@fs/'
 
   extend Forwardable
 
@@ -127,7 +103,7 @@ private
   # Internal: Finds the specified entry in the manifest.
   def find_manifest_entry(name)
     if dev_server_running?
-      {"file" => prefix_vite_asset(name)}
+      { 'file' => prefix_vite_asset(name) }
     else
       manifest[name]
     end
@@ -145,36 +121,29 @@ private
 
   # Internal: Loads and merges the manifest files, resolving the asset paths.
   def load_manifest
-    config.manifest_paths
-      .map { |path| JSON.parse(path.read) }
-      .inject({}, &:merge)
-      .tap { |manifest| resolve_references(manifest) }
+    files = [config.manifest_path, config.assets_manifest_path].select(&:exist?)
+    files.map { |path| JSON.parse(path.read) }.inject({}, &:merge).tap(&method(:resolve_references))
   end
 
   # Internal: Scopes an asset to the output folder in public, as a path.
   def prefix_vite_asset(path)
-    File.join(vite_asset_origin || "/", config.public_output_dir, path)
+    File.join("/#{ config.public_output_dir }", path)
   end
 
   # Internal: Prefixes an asset with the `asset_host` for tags that do not use
   # the framework tag helpers.
   def prefix_asset_with_host(path)
-    File.join(vite_asset_origin || config.asset_host || "/", config.public_output_dir, path)
-  end
-
-  # Internal: The origin of assets managed by Vite.
-  def vite_asset_origin
-    config.origin if dev_server_running? && config.skip_proxy
+    File.join(config.asset_host || '/', config.public_output_dir, path)
   end
 
   # Internal: Resolves the paths that reference a manifest entry.
   def resolve_references(manifest)
     manifest.each_value do |entry|
-      entry["file"] = prefix_vite_asset(entry["file"])
+      entry['file'] = prefix_vite_asset(entry['file'])
       %w[css assets].each do |key|
         entry[key] = entry[key].map { |path| prefix_vite_asset(path) } if entry[key]
       end
-      entry["imports"]&.map! { |name| manifest.fetch(name) }
+      entry['imports']&.map! { |name| manifest.fetch(name) }
     end
   end
 
@@ -183,7 +152,7 @@ private
     return resolve_virtual_entry(name) if type == :virtual
 
     name = with_file_extension(name.to_s, type)
-    raise ArgumentError, "Asset names can not be relative. Found: #{name}" if name.start_with?(".")
+    raise ArgumentError, "Asset names can not be relative. Found: #{ name }" if name.start_with?('.')
 
     # Explicit path, relative to the source_code_dir.
     name.sub(%r{^~/(.+)$}) { return Regexp.last_match(1) }
@@ -192,7 +161,7 @@ private
     name.sub(%r{^/(.+)$}) { return resolve_absolute_entry(Regexp.last_match(1)) }
 
     # Sugar: Prefix with the entrypoints dir if the path is not nested.
-    name.include?("/") ? name : File.join(config.entrypoints_dir, name)
+    name.include?('/') ? name : File.join(config.entrypoints_dir, name)
   end
 
   # Internal: Entry names in the manifest are relative to the Vite.js.
@@ -213,7 +182,7 @@ private
   # Internal: Adds a file extension to the file name, unless it already has one.
   def with_file_extension(name, entry_type)
     if File.extname(name).empty? && (ext = extension_for_type(entry_type))
-      "#{name}.#{ext}"
+      "#{ name }.#{ ext }"
     else
       name
     end
@@ -222,16 +191,16 @@ private
   # Internal: Allows to receive :javascript and :stylesheet as :type in helpers.
   def extension_for_type(entry_type)
     case entry_type
-    when :javascript then "js"
-    when :stylesheet then "css"
-    when :typescript then "ts"
+    when :javascript then 'js'
+    when :stylesheet then 'css'
+    when :typescript then 'ts'
     else entry_type
     end
   end
 
   # Internal: Raises a detailed message when an entry is missing in the manifest.
   def missing_entry_error(name, **options)
-    raise ViteRuby::MissingEntrypointError.new(
+    raise ViteRuby::MissingEntrypointError, OpenStruct.new(
       file_name: resolve_entry_name(name, **options),
       last_build: builder.last_build_metadata,
       manifest: @manifest,

data/lib/vite_ruby/missing_entrypoint_error.rb

@@ -5,38 +5,31 @@
 # NOTE: The complexity here is justified by the improved usability of providing
 # a more specific error message depending on the situation.
 class ViteRuby::MissingEntrypointError < ViteRuby::Error
-  attr_reader :file_name, :last_build, :manifest, :config
+  extend Forwardable
+  def_delegators :@info, :file_name, :last_build, :manifest, :config
 
-  def initialize(file_name:, last_build:, manifest:, config:)
-    @file_name, @last_build, @manifest, @config = file_name, last_build, manifest, config
+  def initialize(info)
+    @info = info
     super <<~MSG
-      Vite Ruby can't find #{file_name} in the manifests.
+      Vite Ruby can't find #{ file_name } in #{ config.manifest_path.relative_path_from(config.root) } or #{ config.assets_manifest_path.relative_path_from(config.root) }.
 
       Possible causes:
-      #{possible_causes(last_build)}
+      #{ possible_causes(last_build) }
       :troubleshooting:
-      #{"Manifest files found:\n#{config.manifest_paths.map { |path| "  #{path.relative_path_from(config.root)}" }.join("\n")}\n" if last_build.success}
-      #{"Last build in #{config.mode} mode:\n#{last_build.to_json}\n" if last_build.success}
+      #{ "\nContent in your manifests:\n#{ JSON.pretty_generate(manifest) }\n" if last_build.success }
+      #{ "Last build in #{ config.mode } mode:\n#{ last_build.to_json }\n" unless last_build.success.nil? }
     MSG
   end
 
   def possible_causes(last_build)
-    if last_build.success == false
-      FAILED_BUILD_CAUSES
-        .sub(":mode:", config.mode)
-        .sub(":errors:", last_build.errors.to_s.gsub(/^(?!$)/, "  "))
-    elsif config.auto_build
-      DEFAULT_CAUSES
-    else
-      DEFAULT_CAUSES + NO_AUTO_BUILD_CAUSES
-    end
-  end
+    return FAILED_BUILD_CAUSES.sub(':mode:', config.mode) if last_build.success == false
+    return DEFAULT_CAUSES if config.auto_build
 
-  FAILED_BUILD_CAUSES = <<~MSG
-      - The last build failed. Try running `bin/vite build --clear --mode=:mode:` manually and check for errors.
+    DEFAULT_CAUSES + NO_AUTO_BUILD_CAUSES
+  end
 
-    Errors:
-    :errors:
+  FAILED_BUILD_CAUSES = <<-MSG
+  - The last build failed. Try running `bin/vite build --clear --mode=:mode:` manually and check for errors.
   MSG
 
   DEFAULT_CAUSES = <<-MSG

data/lib/vite_ruby/missing_executable_error.rb

@@ -7,7 +7,7 @@ class ViteRuby::MissingExecutableError < ViteRuby::Error
       ❌ The vite binary is not available. Have you installed the npm packages?
 
       :troubleshooting:
-      #{error}
+      #{ error }
     MSG
   end
 end

data/lib/vite_ruby/runner.rb

@@ -8,11 +8,11 @@ class ViteRuby::Runner
 
   # Public: Executes Vite with the specified arguments.
   def run(argv, exec: false)
-    config.within_root {
+    Dir.chdir(config.root) {
       cmd = command_for(argv)
       return Kernel.exec(*cmd) if exec
 
-      log_or_noop = ->(line) { logger.info("vite") { line } } unless config.hide_build_console_output
+      log_or_noop = ->(line) { logger.info('vite') { line } } unless config.hide_build_console_output
       ViteRuby::IO.capture(*cmd, chdir: config.root, with_output: log_or_noop)
     }
   rescue Errno::ENOENT => error
@@ -23,31 +23,23 @@ private
 
   extend Forwardable
 
-  def_delegators :@vite_ruby, :config, :logger, :env
+  def_delegators :@vite_ruby, :config, :logger
 
   # Internal: Returns an Array with the command to run.
   def command_for(args)
-    [config.to_env(env)].tap do |cmd|
-      exec_args, vite_args = args.partition { |arg| arg.start_with?("--node-options") }
-      cmd.push(*vite_executable(*exec_args))
-      cmd.push(*vite_args)
-      cmd.push("--mode", config.mode) unless args.include?("--mode") || args.include?("-m")
+    [config.to_env].tap do |cmd|
+      args = args.clone
+      cmd.push('node', '--inspect-brk') if args.delete('--inspect')
+      cmd.push('node', '--trace-deprecation') if args.delete('--trace_deprecation')
+      cmd.push(vite_executable)
+      cmd.push(*args)
+      cmd.push('--mode', config.mode) unless args.include?('--mode') || args.include?('-m')
     end
   end
 
   # Internal: Resolves to an executable for Vite.
-  def vite_executable(*exec_args)
+  def vite_executable
     bin_path = config.vite_bin_path
-    return [bin_path] if bin_path && File.exist?(bin_path)
-
-    x = case config.package_manager
-    when "npm" then %w[npx]
-    when "pnpm" then %w[pnpm exec]
-    when "bun" then %w[bun x --bun]
-    when "yarn" then %w[yarn]
-    else raise ArgumentError, "Unknown package manager #{config.package_manager.inspect}"
-    end
-
-    [*x, *exec_args, "vite"]
+    File.exist?(bin_path) ? bin_path : "#{ `npm bin`.chomp }/vite"
   end
 end

data/lib/vite_ruby/version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class ViteRuby
-  VERSION = "3.11.0"
+  VERSION = '4.0.0.alpha1'
 
   # Internal: Versions used by default when running `vite install`.
-  DEFAULT_VITE_VERSION = "^8.0.0"
-  DEFAULT_PLUGIN_VERSION = "^5.2.0"
+  DEFAULT_VITE_VERSION = '^2.7.7'
+  DEFAULT_PLUGIN_VERSION = '^3.0.5'
 end