vite_ruby 3.8.2 → 3.9.1

data/lib/vite_ruby/cli/vite.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Vite < Dry::CLI::Command
-  CURRENT_ENV = ENV['RACK_ENV'] || ENV['RAILS_ENV']
+  CURRENT_ENV = ENV["RACK_ENV"] || ENV["RAILS_ENV"]
 
   def self.executable_options
-    option(:mode, default: self::DEFAULT_ENV, values: %w[development production test], aliases: ['m'], desc: 'The build mode for Vite')
-    option(:node_options, desc: 'Node options for the Vite executable', aliases: ['node-options'])
-    option(:inspect, desc: 'Run Vite in a debugging session with node --inspect-brk', aliases: ['inspect-brk'], type: :boolean)
-    option(:trace_deprecation, desc: 'Run Vite in debugging mode with node --trace-deprecation', aliases: ['trace-deprecation'], type: :boolean)
+    option(:mode, default: self::DEFAULT_ENV, values: %w[development production test], aliases: ["m"], desc: "The build mode for Vite")
+    option(:node_options, desc: "Node options for the Vite executable", aliases: ["node-options"])
+    option(:inspect, desc: "Run Vite in a debugging session with node --inspect-brk", aliases: ["inspect-brk"], type: :boolean)
+    option(:trace_deprecation, desc: "Run Vite in debugging mode with node --trace-deprecation", aliases: ["trace-deprecation"], type: :boolean)
   end
 
   def self.shared_options
     executable_options
-    option(:debug, desc: 'Run Vite in verbose mode, printing all debugging output', aliases: ['verbose'], type: :boolean)
-    option(:clobber, desc: 'Clear cache and previous builds', type: :boolean, aliases: %w[clean clear])
+    option(:debug, desc: "Run Vite in verbose mode, printing all debugging output", aliases: ["verbose"], type: :boolean)
+    option(:clobber, desc: "Clear cache and previous builds", type: :boolean, aliases: %w[clean clear])
   end
 
   def call(mode:, args: [], clobber: false, node_options: nil, inspect: nil, trace_deprecation: nil, **boolean_opts)
-    ViteRuby.env['VITE_RUBY_MODE'] = mode
+    ViteRuby.env["VITE_RUBY_MODE"] = mode
     ViteRuby.commands.clobber if clobber
 
     node_options = [
       node_options,
-      ('--inspect-brk' if inspect),
-      ('--trace-deprecation' if trace_deprecation),
-    ].compact.join(' ')
+      ("--inspect-brk" if inspect),
+      ("--trace-deprecation" if trace_deprecation),
+    ].compact.join(" ")
 
-    args << %(--node-options="#{ node_options }") unless node_options.empty?
+    args << %(--node-options="#{node_options}") unless node_options.empty?
 
-    boolean_opts.map { |name, value| args << "--#{ name }" if value }
+    boolean_opts.map { |name, value| args << "--#{name}" if value }
 
     yield(args)
   end

data/lib/vite_ruby/cli.rb

@@ -1,30 +1,30 @@
 # frozen_string_literal: true
 
-require 'dry/cli'
+require "dry/cli"
 
 # Public: Command line interface that allows to install the library, and run
 # simple commands.
 class ViteRuby::CLI
   extend Dry::CLI::Registry
 
-  register 'build', Build, aliases: ['b']
-  register 'clobber', Clobber, aliases: %w[clean clear]
-  register 'dev', Dev, aliases: %w[d serve]
-  register 'install', Install
-  register 'ssr', SSR
-  register 'version', Version, aliases: ['v', '-v', '--version', 'info']
-  register 'upgrade', Upgrade, aliases: ['update']
-  register 'upgrade_packages', UpgradePackages, aliases: ['update_packages']
+  register "build", Build, aliases: ["b"]
+  register "clobber", Clobber, aliases: %w[clean clear]
+  register "dev", Dev, aliases: %w[d serve]
+  register "install", Install
+  register "ssr", SSR
+  register "version", Version, aliases: ["v", "-v", "--version", "info"]
+  register "upgrade", Upgrade, aliases: ["update"]
+  register "upgrade_packages", UpgradePackages, aliases: ["update_packages"]
 
   # Internal: Allows framework-specific variants to extend the CLI.
-  def self.require_framework_libraries(path = 'cli')
+  def self.require_framework_libraries(path = "cli")
     ViteRuby.framework_libraries.each do |_framework, library|
-      require [library.name.tr('-', '/').to_s, path].compact.join('/')
+      require [library.name.tr("-", "/").to_s, path].compact.join("/")
     end
   rescue LoadError
-    require_framework_libraries 'installation' unless path == 'installation'
+    require_framework_libraries "installation" unless path == "installation"
   end
 end
 
 # NOTE: This allows framework-specific variants to extend the CLI.
-ViteRuby::CLI.require_framework_libraries('cli')
+ViteRuby::CLI.require_framework_libraries("cli")

data/lib/vite_ruby/commands.rb

@@ -9,7 +9,7 @@ class ViteRuby::Commands
 
   # Public: Defaults to production, and exits if the build fails.
   def build_from_task(*args)
-    with_node_env(ENV.fetch('NODE_ENV', 'production')) {
+    with_node_env(ENV.fetch("NODE_ENV", "production")) {
       ensure_log_goes_to_stdout {
         build(*args) || exit!
       }
@@ -25,12 +25,12 @@ class ViteRuby::Commands
   def clobber
     dirs = [config.build_output_dir, config.ssr_output_dir, config.build_cache_dir, config.vite_cache_dir]
     dirs.each { |dir| dir.rmtree if dir.exist? }
-    $stdout.puts "Removed vite cache and output dirs:\n\t#{ dirs.join("\n\t") }"
+    $stdout.puts "Removed vite cache and output dirs:\n\t#{dirs.join("\n\t")}"
   end
 
   # Internal: Installs the binstub for the CLI in the appropriate path.
   def install_binstubs
-    `bundle binstub vite_ruby --path #{ config.root.join('bin') }`
+    `bundle binstub vite_ruby --path #{config.root.join("bin")}`
     `bundle config --delete bin`
   end
 
@@ -46,7 +46,7 @@ class ViteRuby::Commands
 
   # Internal: Verifies if ViteRuby is properly installed.
   def verify_install
-    unless File.exist?(config.root.join('bin/vite'))
+    unless File.exist?(config.root.join("bin/vite"))
       warn <<~WARN
 
         vite binstub not found.
@@ -59,7 +59,7 @@ class ViteRuby::Commands
     unless config_path.exist?
       warn <<~WARN
 
-        Configuration #{ config_path } file for vite-plugin-ruby not found.
+        Configuration #{config_path} file for vite-plugin-ruby not found.
         Make sure `bundle exec vite install` has run successfully before running dependent tasks.
       WARN
       exit!
@@ -69,23 +69,23 @@ class ViteRuby::Commands
   # Internal: Prints information about ViteRuby's environment.
   def print_info
     config.within_root do
-      $stdout.puts "bin/vite present?: #{ File.exist? 'bin/vite' }"
+      $stdout.puts "bin/vite present?: #{File.exist? "bin/vite"}"
 
-      $stdout.puts "vite_ruby: #{ ViteRuby::VERSION }"
+      $stdout.puts "vite_ruby: #{ViteRuby::VERSION}"
       ViteRuby.framework_libraries.each do |framework, library|
-        $stdout.puts "#{ library.name }: #{ library.version }"
-        $stdout.puts "#{ framework }: #{ Gem.loaded_specs[framework]&.version }"
+        $stdout.puts "#{library.name}: #{library.version}"
+        $stdout.puts "#{framework}: #{Gem.loaded_specs[framework]&.version}"
       end
 
-      $stdout.puts "ruby: #{ `ruby --version` }"
-      $stdout.puts "node: #{ `node --version` }"
+      $stdout.puts "ruby: #{`ruby --version`}"
+      $stdout.puts "node: #{`node --version`}"
 
       pkg = config.package_manager
-      $stdout.puts "#{ pkg }: #{ `#{ pkg } --version` rescue nil }"
+      $stdout.puts "#{pkg}: #{`#{pkg} --version` rescue nil}"
 
       $stdout.puts "\n"
       packages = `npm ls vite vite-plugin-ruby`
-      packages_msg = packages.include?('vite@') ? "installed packages:\n#{ packages }" : '❌ Check that vite and vite-plugin-ruby have been added as development dependencies and installed.'
+      packages_msg = packages.include?("vite@") ? "installed packages:\n#{packages}" : "❌ Check that vite and vite-plugin-ruby have been added as development dependencies and installed."
       $stdout.puts packages_msg
 
       ViteRuby::CompatibilityCheck.verify_plugin_version(config.root)
@@ -99,18 +99,18 @@ private
   def_delegators :@vite_ruby, :config, :builder, :manifest, :logger, :logger=
 
   def with_node_env(env)
-    original = ENV['NODE_ENV']
-    ENV['NODE_ENV'] = env
+    original = ENV["NODE_ENV"]
+    ENV["NODE_ENV"] = env
     yield
   ensure
-    ENV['NODE_ENV'] = original
+    ENV["NODE_ENV"] = original
   end
 
   def ensure_log_goes_to_stdout
     old_logger, original_sync = logger, $stdout.sync
 
     $stdout.sync = true
-    self.logger = Logger.new($stdout, formatter: proc { |_, _, progname, msg| progname == 'vite' ? msg : "#{ msg }\n" })
+    self.logger = Logger.new($stdout, formatter: proc { |_, _, progname, msg| (progname == "vite") ? msg : "#{msg}\n" })
     yield
   ensure
     self.logger, $stdout.sync = old_logger, original_sync

data/lib/vite_ruby/compatibility_check.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 # Internal: Verifies that the installed vite-plugin-ruby version is compatible
 # with the current version of vite_ruby.
@@ -11,9 +11,9 @@ module ViteRuby::CompatibilityCheck
   class << self
     # Public: Attempt to verify that the vite-plugin-ruby version is compatible.
     def verify_plugin_version(root)
-      package = JSON.parse(root.join('package.json').read) rescue {}
-      requirement = package.dig('devDependencies', 'vite-plugin-ruby') ||
-                    package.dig('dependencies', 'vite-plugin-ruby')
+      package = JSON.parse(root.join("package.json").read) rescue {}
+      requirement = package.dig("devDependencies", "vite-plugin-ruby") ||
+        package.dig("dependencies", "vite-plugin-ruby")
 
       raise_unless_satisfied(requirement, ViteRuby::DEFAULT_PLUGIN_VERSION)
     end
@@ -22,7 +22,7 @@ module ViteRuby::CompatibilityCheck
     def raise_unless_satisfied(npm_req, ruby_req)
       unless compatible_plugin?(npm_req, ruby_req)
         raise ArgumentError, <<~ERROR
-          vite-plugin-ruby@#{ npm_req } might not be compatible with vite_ruby-#{ ViteRuby::VERSION }
+          vite-plugin-ruby@#{npm_req} might not be compatible with vite_ruby-#{ViteRuby::VERSION}
 
           You may disable this check if needed: https://vite-ruby.netlify.app/config/#skipcompatibilitycheck
 
@@ -37,12 +37,12 @@ module ViteRuby::CompatibilityCheck
     # requirement.
     def compatible_plugin?(npm_req, ruby_req)
       npm_req, ruby_req = [npm_req, ruby_req]
-        .map { |req| Gem::Requirement.new(req.sub('^', '~>')) }
+        .map { |req| Gem::Requirement.new(req.sub("^", "~>")) }
 
       current_version = npm_req.requirements.first.second
 
       ruby_req.satisfied_by?(current_version)
-    rescue StandardError
+    rescue
       true
     end
   end

data/lib/vite_ruby/config.rb

@@ -1,35 +1,31 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 # Public: Allows to resolve configuration sourced from `config/vite.json` and
 # environment variables, combining them with the default options.
 class ViteRuby::Config
   def origin
-    "#{ protocol }://#{ host_with_port }"
+    "#{protocol}://#{host_with_port}"
   end
 
   def protocol
-    https ? 'https' : 'http'
+    https ? "https" : "http"
   end
 
   def host_with_port
-    "#{ host }:#{ port }"
+    "#{host}:#{port}"
   end
 
   # Internal: Path to the manifest files generated by Vite and vite-plugin-ruby.
   def known_manifest_paths
     [
       # NOTE: Generated by Vite when `manifest: true`, which vite-plugin-ruby enables.
-      'manifest.json',
+      build_output_dir.join(".vite/manifest.json"),
+
       # NOTE: Path where vite-plugin-ruby outputs the assets manifest file.
-      'manifest-assets.json',
-    ].flat_map { |path|
-      [
-        build_output_dir.join(".vite/#{ path }"), # Vite 5 onwards
-        build_output_dir.join(path), # Vite 4 and below
-      ]
-    }
+      build_output_dir.join(".vite/manifest-assets.json"),
+    ]
   end
 
   # Internal: Path to the manifest files generated by Vite and vite-plugin-ruby.
@@ -49,7 +45,7 @@ class ViteRuby::Config
 
   # Internal: The directory where Vite stores its processing cache.
   def vite_cache_dir
-    root.join('node_modules/.vite')
+    root.join("node_modules/.vite")
   end
 
   # Public: The directory that Vite uses as root.
@@ -59,7 +55,7 @@ class ViteRuby::Config
 
   # Public: Loads an optional config/vite.rb file that can modify ViteRuby.env
   def load_ruby_config
-    rb_config_path = File.expand_path(config_path.sub(/.json$/, '.rb'), root)
+    rb_config_path = File.expand_path(config_path.sub(/.json$/, ".rb"), root)
     load rb_config_path if File.exist?(rb_config_path)
   end
 
@@ -67,7 +63,7 @@ class ViteRuby::Config
   def to_env(env_vars = ViteRuby.env)
     CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env|
       unless (value = @config[option]).nil?
-        env["#{ ViteRuby::ENV_PREFIX }_#{ option.upcase }"] = value.to_s
+        env["#{ViteRuby::ENV_PREFIX}_#{option.upcase}"] = value.to_s
       end
     end.merge(env_vars)
   end
@@ -76,10 +72,10 @@ class ViteRuby::Config
   def watched_paths
     [
       *(watch_additional_paths + additional_entrypoints).reject { |dir|
-        dir.start_with?('~/') || dir.start_with?(source_code_dir)
+        dir.start_with?("~/") || dir.start_with?(source_code_dir)
       },
-      "#{ source_code_dir }/**/*",
-      config_path.sub(/.json$/, '.{rb,json}'),
+      "#{source_code_dir}/**/*",
+      config_path.sub(/.json$/, ".{rb,json}"),
       *DEFAULT_WATCHED_PATHS,
     ].freeze
   end
@@ -94,27 +90,28 @@ private
   # Internal: Coerces all the configuration values, in case they were passed
   # as environment variables which are always strings.
   def coerce_values(config)
-    config['mode'] = config['mode'].to_s
-    config['port'] = config['port'].to_i
-    config['root'] = root = Pathname.new(config['root'])
-    config['build_cache_dir'] = root.join(config['build_cache_dir'])
-    config['ssr_output_dir'] = root.join(config['ssr_output_dir'])
-    coerce_booleans(config, 'auto_build', 'hide_build_console_output', 'https', 'skip_compatibility_check', 'skip_proxy')
-    config['package_manager'] ||= detect_package_manager(root)
+    config["mode"] = config["mode"].to_s
+    config["port"] = config["port"].to_i
+    config["root"] = root = Pathname.new(config["root"])
+    config["build_cache_dir"] = root.join(config["build_cache_dir"])
+    config["ssr_output_dir"] = root.join(config["ssr_output_dir"])
+    coerce_booleans(config, "auto_build", "hide_build_console_output", "https", "skip_compatibility_check", "skip_proxy")
+    config["package_manager"] ||= detect_package_manager(root)
   end
 
   # Internal: Coerces configuration options to boolean.
   def coerce_booleans(config, *names)
-    names.each { |name| config[name] = [true, 'true'].include?(config[name]) }
+    truthy = [true, "true"]
+    names.each { |name| config[name] = truthy.include?(config[name]) }
   end
 
   def detect_package_manager(root)
-    return 'npm' if root.join('package-lock.json').exist?
-    return 'pnpm' if root.join('pnpm-lock.yaml').exist?
-    return 'bun' if root.join('bun.lockb').exist?
-    return 'yarn' if root.join('yarn.lock').exist?
+    return "npm" if root.join("package-lock.json").exist?
+    return "pnpm" if root.join("pnpm-lock.yaml").exist?
+    return "bun" if root.join("bun.lockb").exist?
+    return "yarn" if root.join("yarn.lock").exist?
 
-    'npm'
+    "npm"
   end
 
   def initialize(attrs)
@@ -128,8 +125,8 @@ private
     # Public: Returns the project configuration for Vite.
     def resolve_config(**attrs)
       config = config_defaults.merge(attrs.transform_keys(&:to_s))
-      file_path = File.join(config['root'], config['config_path'])
-      file_config = config_from_file(file_path, mode: config['mode'])
+      file_path = File.join(config["root"], config["config_path"])
+      file_config = config_from_file(file_path, mode: config["mode"])
       new DEFAULT_CONFIG.merge(file_config).merge(config_from_env).merge(config)
     end
 
@@ -137,20 +134,20 @@ private
 
     # Internal: Converts camelCase to snake_case.
     SNAKE_CASE = ->(camel_cased_word) {
-      camel_cased_word.to_s.gsub(/::/, '/')
+      camel_cased_word.to_s.gsub("::", "/")
         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .tr('-', '_')
+        .tr("-", "_")
         .downcase
     }
 
     # Internal: Default values for a Ruby application.
-    def config_defaults(asset_host: nil, mode: ENV.fetch('RACK_ENV', 'development'), root: Dir.pwd)
+    def config_defaults(asset_host: nil, mode: ENV.fetch("RACK_ENV", "development"), root: Dir.pwd)
       {
-        'asset_host' => option_from_env('asset_host') || asset_host,
-        'config_path' => option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path'),
-        'mode' => option_from_env('mode') || mode,
-        'root' => option_from_env('root') || root,
+        "asset_host" => option_from_env("asset_host") || asset_host,
+        "config_path" => option_from_env("config_path") || DEFAULT_CONFIG.fetch("config_path"),
+        "mode" => option_from_env("mode") || mode,
+        "root" => option_from_env("root") || root,
       }.select { |_, value| value }
     end
 
@@ -165,7 +162,7 @@ private
 
     # Internal: Retrieves a configuration option from environment variables.
     def option_from_env(name)
-      ViteRuby.env["#{ ViteRuby::ENV_PREFIX }_#{ name.upcase }"]
+      ViteRuby.env["#{ViteRuby::ENV_PREFIX}_#{name.upcase}"]
     end
 
     # Internal: Extracts the configuration options provided as env vars.
@@ -180,16 +177,16 @@ private
     # Internal: Loads the configuration options provided in a JSON file.
     def config_from_file(path, mode:)
       multi_env_config = load_json(path)
-      multi_env_config.fetch('all', {})
+      multi_env_config.fetch("all", {})
         .merge(multi_env_config.fetch(mode, {}))
     rescue Errno::ENOENT => error
-      $stderr << "Check that your vite.json configuration file is available in the load path:\n\n\t#{ error.message }\n\n"
+      $stderr << "Check that your vite.json configuration file is available in the load path:\n\n\t#{error.message}\n\n"
       {}
     end
   end
 
   # Internal: Shared configuration with the Vite plugin for Ruby.
-  DEFAULT_CONFIG = load_json("#{ __dir__ }/../../default.vite.json").freeze
+  DEFAULT_CONFIG = load_json("#{__dir__}/../../default.vite.json").freeze
 
   # Internal: Configuration options that can not be provided as env vars.
   NOT_CONFIGURABLE_WITH_ENV = %w[additional_entrypoints watch_additional_paths].freeze

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(env)
+      super
     else
       @app.call(env)
     end
@@ -30,39 +30,40 @@ 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(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.
   end
 
   def forward_to_vite_dev_server(env)
     rewrite_uri_for_vite(env)
-    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'] = ''
+    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'])
+    path = normalize_uri(env["PATH_INFO"])
     return true if path.start_with?(vite_url_prefix) # Vite asset
-    return true if file_in_vite_root?(path) # Fallback if Vite can serve the file
+
+    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..-1] : path).file?
+    path.include?(".") && # Check for extension, avoid filesystem if possible.
+      config.vite_root_dir.join(path.start_with?("/") ? path[1..] : path).file?
   end
 
   # NOTE: Vite is configured to use 'public_output_dir' as the base, which can
@@ -70,6 +71,6 @@ private
   #
   # 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 }/"
+    @vite_url_prefix ||= config.public_output_dir.empty? ? VITE_DEPENDENCY_PREFIX : "/#{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|
@@ -21,7 +21,7 @@ module ViteRuby::IO
 
     # 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