vite_ruby 3.11.1 → 4.0.0.alpha1

data/lib/tasks/vite.rake

@@ -2,49 +2,36 @@
 
 $stdout.sync = true
 
-require "rake"
+require 'rake'
 
 namespace :vite do
   task :binstubs do
     ViteRuby.commands.install_binstubs
   end
 
-  desc "Bundle frontend entrypoints using ViteRuby"
-  task build: :"vite:verify_install" do
+  desc 'Compile JavaScript packs using vite for production with digests'
+  task build: :'vite:verify_install' do
     ViteRuby.commands.build_from_task
   end
 
-  desc "Bundle a Node.js app from the SSR entrypoint using ViteRuby"
-  task build_ssr: :"vite:verify_install" do
-    ViteRuby.commands.build_from_task("--ssr")
+  desc 'Remove old compiled vites'
+  task :clean, [:keep, :age] => :'vite:verify_install' do |_, args|
+    ViteRuby.commands.clean_from_task(args)
   end
 
-  desc "Bundle entrypoints using Vite Ruby (SSR only if enabled)"
-  task build_all: :"vite:verify_install" do
-    ViteRuby.commands.build_from_task
-    ViteRuby.commands.build_from_task("--ssr") if ViteRuby.config.ssr_build_enabled
-  end
-
-  desc "Remove the build output directory for ViteRuby"
-  task clobber: :"vite:verify_install" do
+  desc 'Remove the vite build output directory'
+  task clobber: :'vite:verify_install' do
     ViteRuby.commands.clobber
   end
 
-  desc "Verify if ViteRuby is properly installed in the app"
+  desc 'Verifies if ViteRuby is properly installed in this application'
   task :verify_install do
     ViteRuby.commands.verify_install
   end
 
-  desc "Ensure build dependencies like Vite are installed before bundling"
+  desc 'Ensures build dependencies like Vite are installed when compiling assets'
   task :install_dependencies do
-    install_env_args = (ENV["VITE_RUBY_SKIP_INSTALL_DEV_DEPENDENCIES"] == "true") ? {} : {"NODE_ENV" => "development"}
-
-    install_cmd = case (pkg = ViteRuby.config.package_manager)
-    when "npm" then "npm ci"
-    else "#{pkg} install --frozen-lockfile"
-    end
-
-    system(install_env_args, install_cmd)
+    system({ 'NODE_ENV' => 'development' }, 'npx --yes ci')
   end
 
   desc "Provide information on ViteRuby's environment"
@@ -53,43 +40,19 @@ namespace :vite do
   end
 end
 
-unless ENV["VITE_RUBY_SKIP_ASSETS_PRECOMPILE_EXTENSION"] == "true"
-  if Rake::Task.task_defined?("assets:precompile")
-    Rake::Task["assets:precompile"].enhance do |task|
+unless ENV['VITE_RUBY_SKIP_ASSETS_PRECOMPILE_EXTENSION'] == 'true'
+  if Rake::Task.task_defined?('assets:precompile')
+    Rake::Task['assets:precompile'].enhance do |task|
       prefix = task.name.split(/#|assets:precompile/).first
-      unless ENV["VITE_RUBY_SKIP_ASSETS_PRECOMPILE_INSTALL"] == "true"
-        Rake::Task["#{prefix}vite:install_dependencies"].invoke
-      end
-      Rake::Task["#{prefix}vite:build_all"].invoke
+      Rake::Task["#{ prefix }vite:build"].invoke
     end
   else
-    desc "Bundle Vite assets"
-    if ENV["VITE_RUBY_SKIP_ASSETS_PRECOMPILE_INSTALL"] == "true"
-      Rake::Task.define_task("assets:precompile" => "vite:build_all")
-    else
-      Rake::Task.define_task("assets:precompile" => ["vite:install_dependencies", "vite:build_all"])
-    end
-  end
-
-  if Rake::Task.task_defined?("assets:clobber")
-    Rake::Task["assets:clobber"].enhance do
-      Rake::Task["vite:clobber"].invoke
-    end
-  else
-    desc "Remove compiled assets"
-    Rake::Task.define_task("assets:clobber" => "vite:clobber")
+    Rake::Task.define_task('assets:precompile' => ['vite:install_dependencies', 'vite:build'])
   end
 end
 
 # Any prerequisite task that installs packages should also install build dependencies.
-if ARGV.include?("assets:precompile")
-  if ViteRuby.commands.legacy_npm_version?
-    ENV["NPM_CONFIG_PRODUCTION"] = "false"
-  else
-    ENV["NPM_CONFIG_INCLUDE"] = "dev"
-  end
-
-  if ViteRuby.commands.legacy_yarn_version?
-    ENV["YARN_PRODUCTION"] = "false"
-  end
+if ARGV.include?('assets:precompile')
+  ENV['NPM_CONFIG_PRODUCTION'] = 'false'
+  ENV['YARN_PRODUCTION'] = 'false'
 end

data/lib/vite_ruby/build.rb

@@ -1,35 +1,18 @@
 # frozen_string_literal: true
 
-require "json"
-require "time"
+require 'time'
 
 # Internal: Value object with information about the last build.
-ViteRuby::Build = Struct.new(:success, :timestamp, :vite_ruby, :digest, :current_digest, :last_build_path, :errors, keyword_init: true) do
-  class << self
-    # Internal: Combines information from a previous build with the current digest.
-    def from_previous(last_build_path, current_digest)
-      new(
-        **parse_metadata(last_build_path),
-        current_digest: current_digest,
-        last_build_path: last_build_path,
-      )
-    end
-
-  private
-
-    # Internal: Reads metadata recorded on the last build, if it exists.
-    def parse_metadata(pathname)
-      return default_metadata unless pathname.exist?
-
-      JSON.parse(pathname.read.to_s).transform_keys(&:to_sym).slice(*members)
-    rescue JSON::JSONError, Errno::ENOENT, Errno::ENOTDIR
-      default_metadata
-    end
-
-    # Internal: To make it evident that there's no last build in error messages.
-    def default_metadata
-      {timestamp: "never", digest: "none"}
-    end
+ViteRuby::Build = Struct.new(:success, :timestamp, :vite_ruby, :digest, :current_digest) do
+  # Internal: Combines information from a previous build with the current digest.
+  def self.from_previous(attrs, current_digest)
+    new(
+      attrs['success'],
+      attrs['timestamp'] || 'never',
+      attrs['vite_ruby'] || 'unknown',
+      attrs['digest'] || 'none',
+      current_digest,
+    )
   end
 
   # Internal: A build is considered stale when watched files have changed since
@@ -53,30 +36,17 @@ ViteRuby::Build = Struct.new(:success, :timestamp, :vite_ruby, :digest, :current
   end
 
   # Internal: Returns a new build with the specified result.
-  def with_result(**attrs)
+  def with_result(success)
     self.class.new(
-      **attrs,
-      timestamp: Time.now.strftime("%F %T"),
-      vite_ruby: ViteRuby::VERSION,
-      digest: current_digest,
-      current_digest: current_digest,
-      last_build_path: last_build_path,
+      success,
+      Time.now.strftime('%F %T'),
+      ViteRuby::VERSION,
+      current_digest,
     )
   end
 
-  # Internal: Writes the result of the new build to a local file.
-  def write_to_cache
-    last_build_path.write to_json
-  end
-
   # Internal: Returns a JSON string with the metadata of the build.
   def to_json(*_args)
-    JSON.pretty_generate(
-      success: success,
-      errors: errors,
-      timestamp: timestamp,
-      vite_ruby: vite_ruby,
-      digest: digest,
-    )
+    JSON.pretty_generate(to_h)
   end
 end

data/lib/vite_ruby/builder.rb

@@ -1,36 +1,32 @@
 # frozen_string_literal: true
 
-require "digest/sha1"
+require 'json'
+require 'digest/sha1'
 
 # Public: Keeps track of watched files and triggers builds as needed.
 class ViteRuby::Builder
   def initialize(vite_ruby)
     @vite_ruby = vite_ruby
-    @file_digests = {}
   end
 
   # Public: Checks if the watched files have changed since the last compilation,
   # and triggers a Vite build if any files have changed.
   def build(*args)
-    last_build = last_build_metadata(ssr: args.include?("--ssr"))
-
-    if args.delete("--force") || last_build.stale? || config.manifest_paths.empty?
-      stdout, stderr, status = build_with_vite(*args)
-      log_build_result(stdout, stderr, status)
-      record_build_metadata(last_build, errors: stderr, success: status.success?)
-      status.success?
+    last_build = last_build_metadata
+    if args.delete('--force') || last_build.stale?
+      build_with_vite(*args).tap { |success| record_build_metadata(success, last_build) }
     elsif last_build.success
-      logger.debug "Skipping vite build. Watched files have not changed since the last build at #{last_build.timestamp}"
+      logger.debug "Skipping vite build. Watched files have not changed since the last build at #{ last_build.timestamp }"
       true
     else
-      logger.error "Skipping vite build. Watched files have not changed since the build failed at #{last_build.timestamp} ❌"
+      logger.error "Skipping vite build. Watched files have not changed since the build failed at #{ last_build.timestamp } ❌"
       false
     end
   end
 
   # Internal: Reads the result of the last compilation from disk.
-  def last_build_metadata(ssr: false)
-    ViteRuby::Build.from_previous(last_build_path(ssr: ssr), watched_files_digest)
+  def last_build_metadata
+    ViteRuby::Build.from_previous(last_build_attrs, watched_files_digest)
   end
 
 private
@@ -39,70 +35,44 @@ private
 
   def_delegators :@vite_ruby, :config, :logger, :run
 
+  # Internal: Reads metadata recorded on the last build, if it exists.
+  def last_build_attrs
+    last_build_path.exist? ? JSON.parse(last_build_path.read.to_s) : {}
+  rescue JSON::JSONError, Errno::ENOENT, Errno::ENOTDIR
+    {}
+  end
+
   # Internal: Writes a digest of the watched files to disk for future checks.
-  def record_build_metadata(build, **attrs)
+  def record_build_metadata(success, build)
     config.build_cache_dir.mkpath
-    build.with_result(**attrs).write_to_cache
+    last_build_path.write build.with_result(success).to_json
   end
 
   # Internal: The file path where metadata of the last build is stored.
-  def last_build_path(ssr:)
-    config.build_cache_dir.join("last#{"-ssr" if ssr}-build-#{config.mode}.json")
+  def last_build_path
+    config.build_cache_dir.join("last-build-#{ config.mode }.json")
   end
 
   # Internal: Returns a digest of all the watched files, allowing to detect
   # changes, and skip Vite builds if no files have changed.
   def watched_files_digest
-    return @last_digest if @last_digest_at && Time.now - @last_digest_at < 1
-
-    config.within_root do
-      previous_digests = @file_digests
-      @file_digests = {}
-      file_ids = Dir[*config.watched_paths].sort.filter_map { |file|
-        file_digest(file, previous_digests)
-      }
-      @last_digest_at = Time.now
-      @last_digest = Digest::SHA1.hexdigest(file_ids.join("/"))
+    Dir.chdir File.expand_path(config.root) do
+      files = Dir[*config.watched_paths].reject { |f| File.directory?(f) }
+      file_ids = files.sort.map { |f| "#{ File.basename(f) }/#{ Digest::SHA1.file(f).hexdigest }" }
+      Digest::SHA1.hexdigest(file_ids.join('/'))
     end
   end
 
-  # Internal: Returns the id of a watched file, or nil if it's a directory.
-  #
-  # NOTE: Reading and hashing every watched file dominates the cost of the
-  # check, and the answer is almost always the same one as the last time, so the
-  # contents are read again only once the file has been touched. The digest
-  # stays content-based: a checkout that changes mtimes but not contents still
-  # counts as unchanged, and no Vite build is triggered.
-  def file_digest(file, previous_digests)
-    stat = File.stat(file)
-    return if stat.directory?
-
-    signature = [stat.mtime, stat.size]
-    previous_signature, previous_id = previous_digests[file]
-    id = if previous_signature == signature && !recently_modified?(stat)
-      previous_id
-    else
-      "#{File.basename(file)}/#{Digest::SHA1.file(file).hexdigest}"
-    end
-    @file_digests[file] = [signature, id]
-    id
-  end
-
-  # Internal: Whether the file was modified too recently to trust its mtime.
-  #
-  # NOTE: A file edited twice within the resolution of the file system clock,
-  # without changing its size, would keep the same signature. Rehashing the
-  # files touched in the last second rules that out, the same way Git resolves
-  # a racily clean entry in the index.
-  def recently_modified?(stat)
-    Time.now - stat.mtime < 1
-  end
-
   # Public: Initiates a Vite build command to generate assets.
+  #
+  # Returns true if the build is successful, or false if it failed.
   def build_with_vite(*args)
-    logger.info "Building with Vite ⚡️"
+    logger.info 'Building with Vite ⚡️'
+
+    stdout, stderr, status = run(['build', *args])
+    log_build_result(stdout, stderr.to_s, status)
 
-    run(["build", *args])
+    status.success?
   end
 
   # Internal: Outputs the build results.
@@ -110,13 +80,12 @@ private
   # NOTE: By default it also outputs the manifest entries.
   def log_build_result(_stdout, stderr, status)
     if status.success?
-      logger.info "Build with Vite complete: #{config.build_output_dir}"
-      logger.error stderr unless stderr.empty?
+      logger.info "Build with Vite complete: #{ config.build_output_dir }"
+      logger.error stderr.to_s unless stderr.empty?
     else
       logger.error stderr
-      logger.error status
-      logger.error "Build with Vite failed! ❌"
-      logger.error "❌ Check that vite and vite-plugin-ruby are in devDependencies and have been installed. " if stderr.include?("ERR! canceled")
+      logger.error 'Build with Vite failed! ❌'
+      logger.error '❌ Check that vite and vite-plugin-ruby are in devDependencies and have been installed. ' if stderr.include?('ERR! canceled')
     end
   end
 end

data/lib/vite_ruby/cli/build.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Build < ViteRuby::CLI::Vite
-  DEFAULT_ENV = CURRENT_ENV || "production"
+  DEFAULT_ENV = CURRENT_ENV || 'production'
 
-  desc "Bundle all entrypoints using Vite."
+  desc 'Bundle all entrypoints using Vite.'
   shared_options
-  option(:ssr, desc: "Build the SSR entrypoint instead", type: :boolean)
-  option(:force, desc: "Force the build even if assets have not changed", type: :boolean)
-  option(:watch, desc: "Start the Rollup watcher and rebuild on files changes", type: :boolean)
-  option(:profile, desc: "Gather performance metrics from the build ", type: :boolean)
+  option(:force, desc: 'Force the build even if assets have not changed', type: :boolean)
+  option(:watch, desc: 'Start the Rollup watcher and rebuild on files changes', type: :boolean)
 
   def call(**options)
     super { |args| ViteRuby.commands.build_from_task(*args) }

data/lib/vite_ruby/cli/clobber.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Clobber < Dry::CLI::Command
-  desc "Clear the Vite cache, temp files, and builds"
+  desc 'Clear the Vite cache, temp files, and builds'
 
-  current_env = ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+  current_env = ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
 
-  option(:mode, default: current_env, values: %w[development production test], aliases: ["m"], desc: "The mode to use")
+  option(:mode, default: current_env, values: %w[development production test], aliases: ['m'], desc: 'The mode to use')
 
   def call(mode:, **)
-    ViteRuby.env["VITE_RUBY_MODE"] = mode
+    ViteRuby.env['VITE_RUBY_MODE'] = mode
     ViteRuby.commands.clobber
   end
 end

data/lib/vite_ruby/cli/dev.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 class ViteRuby::CLI::Dev < ViteRuby::CLI::Vite
-  DEFAULT_ENV = CURRENT_ENV || "development"
+  DEFAULT_ENV = CURRENT_ENV || 'development'
 
-  desc "Start the Vite development server."
+  desc 'Start the Vite development server.'
   shared_options
-  option(:force, desc: "Force Vite to re-bundle dependencies", type: :boolean)
+  option(:force, desc: 'Force Vite to re-bundle dependencies', type: :boolean)
 
   def call(**options)
     super { |args| ViteRuby.run(args, exec: true) }

data/lib/vite_ruby/cli/file_utils.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "pathname"
-require "fileutils"
+require 'pathname'
+require 'fileutils'
 
 # NOTE: Extracted from dry-cli version 0.6.0, which later removed this file as
 # it was refactored and extracted into the more complete (and complex) dry-files.
@@ -32,18 +32,11 @@ module ViteRuby::CLI::FileUtils
     # @since 1.2.11
     # @api private
     def append(path, contents)
-      append_unless_present(path, contents, pattern: contents)
-    end
-
-    # Adds a new line at the bottom of the file, unless any line matches the pattern.
-    #
-    # @api private
-    def append_unless_present(path, contents, pattern:)
       content = read_lines(path)
-      return if content.any? { |line| line.include?(pattern) }
+      return if content.join.include?(contents)
 
       content << "\n" unless content.last&.end_with?("\n")
-      content << "#{contents}\n"
+      content << "#{ contents }\n"
 
       write(path, content)
     end
@@ -54,7 +47,7 @@ module ViteRuby::CLI::FileUtils
     # @api private
     def replace_first_line(path, target, replacement)
       content = read_lines(path)
-      content[index(content, path, target)] = "#{replacement}\n"
+      content[index(content, path, target)] = "#{ replacement }\n"
 
       write(path, content)
     end
@@ -102,14 +95,14 @@ module ViteRuby::CLI::FileUtils
     # @api private
     def index(content, path, target)
       content.index { |line| line.include?(target) } ||
-        raise(ArgumentError, "Cannot find `#{target}' inside `#{path}'.")
+        raise(ArgumentError, "Cannot find `#{ target }' inside `#{ path }'.")
     end
 
     # @since 1.2.11
     # @api private
     def rindex(content, path, target)
       content.rindex { |line| line.include?(target) } ||
-        raise(ArgumentError, "Cannot find `#{target}' inside `#{path}'.")
+        raise(ArgumentError, "Cannot find `#{ target }' inside `#{ path }'.")
     end
 
     # @since 1.2.11
@@ -120,7 +113,7 @@ module ViteRuby::CLI::FileUtils
 
       i = finder.call(content, path, target)
 
-      content.insert(i, "#{contents}\n")
+      content.insert(i, "#{ contents }\n")
       write(path, content)
     end
 
@@ -132,7 +125,7 @@ module ViteRuby::CLI::FileUtils
 
       i = finder.call(content, path, target)
 
-      content.insert(i + 1, "#{contents}\n")
+      content.insert(i + 1, "#{ contents }\n")
       write(path, content)
     end
   end

data/lib/vite_ruby/cli/install.rb

@@ -1,31 +1,26 @@
 # frozen_string_literal: true
 
-require "stringio"
-require "json"
+require 'stringio'
 
 class ViteRuby::CLI::Install < Dry::CLI::Command
-  desc "Performs the initial configuration setup to get started with Vite Ruby."
-
-  option(:package_manager, values: %w[npm pnpm yarn bun], aliases: %w[package-manager with], desc: "The package manager to use when installing JS dependencies.")
-
-  def call(package_manager: nil, **)
-    ENV["VITE_RUBY_PACKAGE_MANAGER"] ||= package_manager if package_manager
+  desc 'Performs the initial configuration setup to get started with Vite Ruby.'
 
+  def call(**)
     $stdout.sync = true
 
-    say "Creating binstub"
+    say 'Creating binstub'
     ViteRuby.commands.install_binstubs
 
-    say "Creating configuration files"
+    say 'Creating configuration files'
     create_configuration_files
 
-    say "Installing sample files"
+    say 'Installing sample files'
     install_sample_files
 
-    say "Installing js dependencies"
+    say 'Installing js dependencies'
     install_js_dependencies
 
-    say "Adding files to .gitignore"
+    say 'Adding files to .gitignore'
     install_gitignore
 
     say "\nVite ⚡️ Ruby successfully installed! 🎉"
@@ -36,38 +31,38 @@ protected
   # Internal: The JS packages that should be added to the app.
   def js_dependencies
     [
-      "vite@#{ViteRuby::DEFAULT_VITE_VERSION}",
-      "vite-plugin-ruby@#{ViteRuby::DEFAULT_PLUGIN_VERSION}",
+      "vite@#{ ViteRuby::DEFAULT_VITE_VERSION }",
+      "vite-plugin-ruby@#{ ViteRuby::DEFAULT_PLUGIN_VERSION }",
     ]
   end
 
   # Internal: Setup for a plain Rack application.
   def setup_app_files
-    copy_template "config/vite.json", to: config.config_path
+    copy_template 'config/vite.json', to: config.config_path
 
-    if (rackup_file = root.join("config.ru")).exist?
-      inject_line_after_last rackup_file, "require", "use(ViteRuby::DevServerProxy, ssl_verify_none: true) if ViteRuby.run_proxy?"
+    if (rackup_file = root.join('config.ru')).exist?
+      inject_line_after_last rackup_file, 'require', 'use(ViteRuby::DevServerProxy, ssl_verify_none: true) if ViteRuby.run_proxy?'
     end
   end
 
   # Internal: Create a sample JS file and attempt to inject it in an HTML template.
   def install_sample_files
-    copy_template "entrypoints/application.js", to: config.resolved_entrypoints_dir.join("application.js")
+    copy_template 'entrypoints/application.js', to: config.resolved_entrypoints_dir.join('application.js')
   end
 
 private
 
   extend Forwardable
 
-  def_delegators "ViteRuby", :config
+  def_delegators 'ViteRuby', :config
 
-  %i[append append_unless_present cp inject_line_after inject_line_after_last inject_line_before replace_first_line write].each do |util|
-    define_method(util) { |*args, **kwargs, &block|
-      ViteRuby::CLI::FileUtils.send(util, *args, **kwargs, &block) rescue nil
+  %i[append cp inject_line_after inject_line_after_last inject_line_before replace_first_line write].each do |util|
+    define_method(util) { |*args|
+      ViteRuby::CLI::FileUtils.send(util, *args) rescue nil
     }
   end
 
-  TEMPLATES_PATH = Pathname.new(File.expand_path("../../../templates", __dir__))
+  TEMPLATES_PATH = Pathname.new(File.expand_path('../../../templates', __dir__))
 
   def copy_template(path, to:)
     cp TEMPLATES_PATH.join(path), to
@@ -75,42 +70,33 @@ private
 
   # Internal: Creates the Vite and vite-plugin-ruby configuration files.
   def create_configuration_files
-    copy_template "config/vite.config.ts", to: root.join("vite.config.ts")
-    append root.join("Procfile.dev"), "vite: bin/vite dev"
+    copy_template 'config/vite.config.ts', to: root.join('vite.config.ts')
+    append root.join('Procfile.dev'), 'vite: bin/vite dev'
     setup_app_files
     ViteRuby.reload_with(config_path: config.config_path)
   end
 
   # Internal: Installs vite and vite-plugin-ruby at the project level.
   def install_js_dependencies
-    package_json = root.join("package.json")
-    unless package_json.exist?
-      write package_json, <<~JSON
-        {
-          "private": true,
-          "type": "module"
-        }
-      JSON
-    end
-
-    if (JSON.parse(package_json.read)["type"] != "module" rescue nil)
-      FileUtils.mv root.join("vite.config.ts"), root.join("vite.config.mts"), force: true, verbose: true
-    end
-
-    install_js_packages js_dependencies.join(" ")
+    package_json = root.join('package.json')
+    write(package_json, '{}') unless package_json.exist?
+    deps = js_dependencies.join(' ')
+    run_with_capture("#{ npm_install } -D #{ deps }", stdin_data: "\n")
   end
 
   # Internal: Adds compilation output dirs to git ignore.
   def install_gitignore
-    return unless (gitignore_file = root.join(".gitignore")).exist?
+    return unless (gitignore_file = root.join('.gitignore')).exist?
 
     append(gitignore_file, <<~GITIGNORE)
 
       # Vite Ruby
-      /public/vite*
+      /public/vite
+      /public/vite-dev
+      /public/vite-test
       node_modules
       # Vite uses dotenv and suggests to ignore local-only env files. See
-      # https://vite.dev/guide/env-and-mode.html#env-files
+      # https://vitejs.dev/guide/env-and-mode.html#env-files
       *.local
     GITIGNORE
   end
@@ -127,12 +113,16 @@ private
   def run_with_capture(*args, **options)
     Dir.chdir(root) do
       _, stderr, status = ViteRuby::IO.capture(*args, **options)
-      say(stderr) unless status.success? || stderr.empty?
+      say(stderr) unless status.success? || stderr.to_s.empty?
     end
   end
 
-  def install_js_packages(deps)
-    run_with_capture("#{config.package_manager} add -D #{deps}", stdin_data: "\n")
+  # Internal: Support all popular package managers.
+  def npm_install
+    return 'yarn add' if root.join('yarn.lock').exist?
+    return 'pnpm install' if root.join('pnpm-lock.yaml').exist?
+
+    'npm install'
   end
 
   # Internal: Avoid printing warning about missing vite.json, we will create one.
@@ -144,3 +134,8 @@ private
     $stderr = old_stderr
   end
 end
+
+# NOTE: This allows framework-specific variants to extend the installation.
+ViteRuby.framework_libraries.each do |_framework, library|
+  require "#{ library.name.tr('-', '/') }/installation"
+end