vite_rails 1.0.6 → 1.0.11

data/lib/vite_rails/commands.rb

@@ -11,6 +11,15 @@ class ViteRails::Commands
     manifest.refresh
   end
 
+  # Public: Defaults to production, and exits if the build fails.
+  def build_from_rake
+    with_node_env(ENV.fetch('NODE_ENV', 'production')) {
+      ensure_log_goes_to_stdout {
+        build || exit!
+      }
+    }
+  end
+
   # Public: Builds all assets that are managed by Vite, from the entrypoints.
   def build
     builder.build.tap { manifest.refresh }
@@ -20,6 +29,14 @@ class ViteRails::Commands
   def clobber
     config.build_output_dir.rmtree if config.build_output_dir.exist?
     config.build_cache_dir.rmtree if config.build_cache_dir.exist?
+    config.vite_cache_dir.rmtree if config.vite_cache_dir.exist?
+  end
+
+  # Public: Receives arguments from a rake task.
+  def clean_from_rake(args)
+    ensure_log_goes_to_stdout {
+      clean(keep_up_to: Integer(args.keep || 2), age_in_seconds: Integer(args.age || 3600))
+    }
   end
 
   # Public: Cleanup old assets in the output directory.
@@ -33,21 +50,16 @@ class ViteRails::Commands
   #   To force only 1 backup to be kept: clean(1, 0)
   #   To only keep files created within the last 10 minutes: clean(0, 600)
   def clean(keep_up_to: 2, age_in_seconds: 3600)
-    return false unless config.build_output_dir.exist? && config.manifest_path.exist?
+    return false unless may_clean?
 
-    versions.sort.reverse
+    versions
       .each_with_index
       .drop_while { |(mtime, _), index|
         max_age = [0, Time.now - Time.at(mtime)].max
         max_age < age_in_seconds || index < keep_up_to
       }
-      .each do |(_, files), _index|
-        files.each do |file|
-          next unless File.file?(file)
-
-          File.delete(file)
-          logger.info("Removed #{ file }")
-        end
+      .each do |(_, files), _|
+        clean_files(files)
       end
     true
   end
@@ -56,13 +68,42 @@ private
 
   delegate :config, :builder, :manifest, :logger, to: :@vite_rails
 
+  def may_clean?
+    config.build_output_dir.exist? && config.manifest_path.exist?
+  end
+
+  def clean_files(files)
+    files.select { |file| File.file?(file) }.each do |file|
+      File.delete(file)
+      logger.info("Removed #{ file }")
+    end
+  end
+
   def versions
     all_files = Dir.glob("#{ config.build_output_dir }/**/*")
     entries = all_files - [config.manifest_path] - current_version_files
-    entries.reject { |file| File.directory?(file) }.group_by { |file| File.mtime(file).utc.to_i }
+    entries.reject { |file| File.directory?(file) }
+      .group_by { |file| File.mtime(file).utc.to_i }
+      .sort.reverse
   end
 
   def current_version_files
     Dir.glob(manifest.refresh.values.map { |value| config.build_output_dir.join("#{ value['file'] }*") })
   end
+
+  def with_node_env(env)
+    original = ENV['NODE_ENV']
+    ENV['NODE_ENV'] = env
+    yield
+  ensure
+    ENV['NODE_ENV'] = original
+  end
+
+  def ensure_log_goes_to_stdout
+    old_logger = ViteRails.logger
+    ViteRails.logger = ActiveSupport::Logger.new(STDOUT)
+    yield
+  ensure
+    ViteRails.logger = old_logger
+  end
 end

data/lib/vite_rails/config.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
+require 'json'
+
 # Public: Allows to resolve configuration sourced from `config/vite.json` and
 # environment variables, combining them with the default options.
 class ViteRails::Config
   delegate :as_json, :inspect, to: :@config
 
-  def initialize(config)
-    @config = config.tap { coerce_values(config) }.freeze
-
-    config.each_key do |option|
-      define_singleton_method(option) { @config[option] }
-    end
+  def initialize(attrs)
+    @config = attrs.tap { |config| coerce_values(config) }.freeze
   end
 
   def protocol
@@ -28,7 +26,26 @@ class ViteRails::Config
 
   # Public: The directory where Vite will store the built assets.
   def build_output_dir
-    public_dir.join(public_output_dir)
+    root.join(public_dir, public_output_dir)
+  end
+
+  # Public: The directory where the entries are located.
+  def resolved_entrypoints_dir
+    root.join(source_code_dir, entrypoints_dir)
+  end
+
+  # Internal: The directory where Vite stores its processing cache.
+  def vite_cache_dir
+    root.join('node_modules/.vite')
+  end
+
+  # Public: Sets additional environment variables for vite-plugin-ruby.
+  def to_env
+    CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env|
+      unless (value = @config[option]).nil?
+        env["#{ ViteRails::ENV_PREFIX }_#{ option.upcase }"] = value.to_s
+      end
+    end.merge(ViteRails.env)
   end
 
 private
@@ -36,10 +53,11 @@ private
   # Internal: Coerces all the configuration values, in case they were passed
   # as environment variables which are always strings.
   def coerce_values(config)
-    coerce_booleans(config, 'auto_build', 'https')
-    coerce_paths(config, 'assets_dir', 'build_cache_dir', 'config_path', 'public_dir', 'source_code_dir', 'public_output_dir', 'root')
+    config['mode'] = config['mode'].to_s
     config['port'] = config['port'].to_i
-    config['root'] ||= Rails.root
+    config['root'] = Pathname.new(config['root'])
+    config['build_cache_dir'] = config['root'].join(config['build_cache_dir'])
+    coerce_booleans(config, 'auto_build', 'hide_build_console_output', 'https')
   end
 
   # Internal: Coerces configuration options to boolean.
@@ -47,58 +65,70 @@ private
     names.each { |name| config[name] = [true, 'true'].include?(config[name]) }
   end
 
-  # Internal: Converts configuration options to pathname.
-  def coerce_paths(config, *names)
-    names.each { |name| config[name] = Pathname.new(config[name]) unless config[name].nil? }
-  end
-
   class << self
     # Public: Returns the project configuration for Vite.
-    def resolve_config
-      new DEFAULT_CONFIG.merge(config_from_file).merge(config_from_env)
-    rescue Errno::ENOENT => error
-      warn "Check that your vite.json configuration file is available in the load path. #{ error.message }"
-      new DEFAULT_CONFIG.merge(config_from_env)
+    def resolve_config(**attrs)
+      config = attrs.transform_keys(&:to_s).reverse_merge(config_defaults)
+      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
 
   private
 
+    # Internal: Default values for a Rails application.
+    def config_defaults
+      {
+        'asset_host' => option_from_env('asset_host') || Rails.application&.config&.action_controller&.asset_host,
+        'config_path' => option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path'),
+        'mode' => option_from_env('mode') || Rails.env.to_s,
+        'root' => option_from_env('root') || Rails.root || Dir.pwd,
+      }
+    end
+
     # Internal: Used to load a JSON file from the specified path.
     def load_json(path)
       JSON.parse(File.read(File.expand_path(path))).deep_transform_keys(&:underscore)
     end
 
     # Internal: Retrieves a configuration option from environment variables.
-    def config_option_from_env(name)
-      ENV["#{ ViteRails::ENV_PREFIX }_#{ name.upcase }"]
+    def option_from_env(name)
+      ViteRails.env["#{ ViteRails::ENV_PREFIX }_#{ name.upcase }"]
     end
 
     # Internal: Extracts the configuration options provided as env vars.
     def config_from_env
-      CONFIGURABLE_WITH_ENV.each_with_object({}) do |key, env_vars|
-        if value = config_option_from_env(key)
-          env_vars[key] = value
+      CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env_vars|
+        if value = option_from_env(option)
+          env_vars[option] = value
         end
-      end.merge(mode: vite_mode)
-    end
-
-    # Internal: The mode Vite should run on.
-    def vite_mode
-      config_option_from_env('mode') || Rails.env.to_s
+      end
     end
 
     # Internal: Loads the configuration options provided in a JSON file.
-    def config_from_file
-      path = config_option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path')
+    def config_from_file(path, mode:)
       multi_env_config = load_json(path)
       multi_env_config.fetch('all', {})
-        .merge(multi_env_config.fetch(vite_mode, {}))
+        .merge(multi_env_config.fetch(mode, {}))
+    rescue Errno::ENOENT => error
+      warn "Check that your vite.json configuration file is available in the load path. #{ error.message }"
+      {}
     end
   end
 
   # Internal: Shared configuration with the Vite plugin for Ruby.
   DEFAULT_CONFIG = load_json("#{ __dir__ }/../../package/default.vite.json").freeze
 
+  # Internal: Configuration options that can not be provided as env vars.
+  NOT_CONFIGURABLE_WITH_ENV = %w[watch_additional_paths].freeze
+
   # Internal: Configuration options that can be provided as env vars.
-  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + ['root']).freeze
+  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + %w[mode root] - NOT_CONFIGURABLE_WITH_ENV).freeze
+
+public
+
+  # Define getters for the configuration options.
+  (CONFIGURABLE_WITH_ENV + NOT_CONFIGURABLE_WITH_ENV).each do |option|
+    define_method(option) { @config[option] }
+  end
 end

data/lib/vite_rails/dev_server_proxy.rb

@@ -14,18 +14,8 @@ class ViteRails::DevServerProxy < Rack::Proxy
 
   # Rack: Intercept asset requests and send them to the Vite server.
   def perform_request(env)
-    if vite_should_handle?(env['REQUEST_URI'], env['HTTP_REFERER']) && dev_server.running?
-      env['REQUEST_URI'] = env['REQUEST_URI']
-        .sub(vite_asset_url_prefix, '/')
-        .sub('.ts.js', '.ts') # Patch: Rails helpers always append the extension.
-      env['PATH_INFO'], env['QUERY_STRING'] = env['REQUEST_URI'].split('?')
-
-      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'] = ''
+    if vite_should_handle?(env) && dev_server_running?
+      forward_to_vite_dev_server(env)
       super(env)
     else
       @app.call(env)
@@ -34,13 +24,31 @@ class ViteRails::DevServerProxy < Rack::Proxy
 
 private
 
-  delegate :config, :dev_server, to: :@vite_rails
+  delegate :config, :dev_server_running?, to: :@vite_rails
 
-  def vite_should_handle?(url, referer)
-    return true if url.start_with?(vite_asset_url_prefix) # Vite Asset
-    return true if url.start_with?(VITE_DEPENDENCY_PREFIX) # Vite Package Asset
-    return true if url.include?('?t=') # Hot Reload
-    return true if referer && URI.parse(referer).path.start_with?(vite_asset_url_prefix) # Entry Imported from another Entry.
+  def rewrite_uri_for_vite(env)
+    uri = env.fetch('REQUEST_URI') { [env['PATH_INFO'], env['QUERY_STRING']].reject(&:blank?).join('?') }
+      .sub(vite_asset_url_prefix, '/')
+    env['PATH_INFO'], env['QUERY_STRING'] = (env['REQUEST_URI'] = uri).split('?')
+  end
+
+  def forward_to_vite_dev_server(env)
+    rewrite_uri_for_vite(env)
+    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, query, referer = env['PATH_INFO'], env['QUERY_STRING'], env['HTTP_REFERER']
+    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 query&.start_with?('t=') # Hot Reload for a stylesheet
+    return true if query&.start_with?('import&') # Hot Reload for an imported entrypoint
+    return true if referer && URI.parse(referer).path.start_with?(vite_asset_url_prefix) # Entry imported from another entry.
   end
 
   def vite_asset_url_prefix

data/lib/vite_rails/helper.rb

@@ -2,19 +2,26 @@
 
 # Public: Allows to render HTML tags for scripts and styles processed by Vite.
 module ViteRails::Helper
-  DEFAULT_VITE_SKIP_PRELOAD_TAGS = Rails::VERSION::MAJOR <= 5 && Rails::VERSION::MINOR < 2
+  DEFAULT_VITE_SKIP_PRELOAD_TAGS = Rails.gem_version < Gem::Version.new('5.2.0')
 
   # Public: Returns the current Vite Rails instance.
   def current_vite_instance
     ViteRails.instance
   end
 
-  # Public: Computes the relative path for the specified given Vite asset.
+  # Public: Renders a script tag for vite/client to enable HMR in development.
+  def vite_client_tag
+    return unless current_vite_instance.dev_server_running?
+
+    content_tag('script', '', src: current_vite_instance.manifest.prefix_vite_asset('@vite/client'), type: 'module')
+  end
+
+  # Public: Resolves the path for the specified Vite asset.
   #
   # Example:
   #   <%= vite_asset_path 'calendar.css' %> # => "/vite/assets/calendar-1016838bab065ae1e122.css"
   def vite_asset_path(name, **options)
-    current_vite_instance.manifest.lookup!(name, **options).fetch('file')
+    path_to_asset current_vite_instance.manifest.lookup!(name, **options).fetch('file')
   end
 
   # Public: Renders a <script> tag for the specified Vite entrypoints.
@@ -26,15 +33,17 @@ module ViteRails::Helper
                           crossorigin: 'anonymous',
                           **options)
     js_entries = names.map { |name| current_vite_instance.manifest.lookup!(name, type: asset_type) }
-    js_tags = javascript_include_tag(*js_entries.map { |entry| entry['file'] }, type: type, crossorigin: crossorigin, **options)
+    js_tags = javascript_include_tag(*js_entries.map { |entry| entry['file'] }, crossorigin: crossorigin, type: type, **options)
 
-    unless skip_preload_tags || ViteRails.dev_server.running?
+    unless skip_preload_tags || current_vite_instance.dev_server_running?
       preload_paths = js_entries.flat_map { |entry| entry['imports'] }.compact.uniq
       preload_tags = preload_paths.map { |path| preload_link_tag(path, crossorigin: crossorigin) }
     end
 
-    unless skip_style_tags || ViteRails.dev_server.running?
-      style_paths = names.map { |name| current_vite_instance.manifest.lookup(name, type: :stylesheet)&.fetch('file') }.compact
+    unless skip_style_tags || current_vite_instance.dev_server_running?
+      style_paths = names.map { |name|
+        current_vite_instance.manifest.lookup(name.delete_suffix('.js'), type: :stylesheet)&.fetch('file')
+      }.compact
       style_tags = stylesheet_link_tag(*style_paths)
     end
 
@@ -46,7 +55,7 @@ module ViteRails::Helper
   # NOTE: Because TypeScript is not a valid target in browsers, we only specify
   # the ts file when running the Vite development server.
   def vite_typescript_tag(*names, **options)
-    vite_javascript_tag(*names, asset_type: :typescript, **options)
+    vite_javascript_tag(*names, asset_type: :typescript, extname: false, **options)
   end
 
   # Public: Renders a <link> tag for the specified Vite entrypoints.

data/lib/vite_rails/manifest.rb

@@ -31,7 +31,7 @@ class ViteRails::Manifest
   # Example:
   #   ViteRails.manifest.lookup('calendar.js')
   #   # { "file" => "/vite/assets/calendar-1016838bab065ae1e122.js", "imports" => [] }
-  def lookup(name, type:)
+  def lookup(name, type: nil)
     build if should_build?
 
     find_manifest_entry(with_file_extension(name, type))
@@ -42,6 +42,11 @@ class ViteRails::Manifest
     @manifest = load_manifest
   end
 
+  # Public: Scopes an asset to the output folder in public, as a path.
+  def prefix_vite_asset(path)
+    File.join("/#{ config.public_output_dir }", path)
+  end
+
 private
 
   delegate :config, :builder, :dev_server_running?, to: :@vite_rails
@@ -55,7 +60,7 @@ private
   # Internal: Finds the specified entry in the manifest.
   def find_manifest_entry(name)
     if dev_server_running?
-      { 'file' => "/#{ config.public_output_dir.join(name.to_s) }" }
+      { 'file' => prefix_vite_asset(name.to_s) }
     else
       manifest[name.to_s]
     end
@@ -80,8 +85,8 @@ private
   def load_manifest
     if config.manifest_path.exist?
       JSON.parse(config.manifest_path.read).each do |_, entry|
-        entry['file'] = within_public_output_dir(entry['file'])
-        entry['imports'] = entry['imports']&.map { |path| within_public_output_dir(path) }
+        entry['file'] = prefix_vite_asset(entry['file'])
+        entry['imports'] = entry['imports']&.map { |path| prefix_vite_asset(path) }
       end
     else
       {}
@@ -92,12 +97,8 @@ private
   def with_file_extension(name, entry_type)
     return name unless File.extname(name.to_s).empty?
 
-    "#{ name }.#{ extension_for_type(entry_type) }"
-  end
-
-  # Internal: Scopes the paths in the manifest to the output folder in public.
-  def within_public_output_dir(path)
-    "/#{ config.public_output_dir.join(path) }"
+    extension = extension_for_type(entry_type)
+    extension ? "#{ name }.#{ extension }" : name
   end
 
   # Internal: Allows to receive :javascript and :stylesheet as :type in helpers.
@@ -106,7 +107,7 @@ private
     when :javascript then 'js'
     when :stylesheet then 'css'
     when :typescript then dev_server_running? ? 'ts' : 'js'
-    else entry_type.to_s
+    else entry_type
     end
   end
 
@@ -129,9 +130,10 @@ private
     [
       (dev_server_running? && 'Vite has not yet re-built your latest changes.'),
       (local && !dev_server_running? && "\"autoBuild\": false in your #{ config.mode } configuration."),
+      (local && !dev_server_running? && 'The Vite development server has crashed or is no longer available.'),
       'You have misconfigured config/vite.json file.',
       (!local && 'Assets have not been precompiled'),
-    ].select(&:itself)
+    ].compact
   rescue StandardError
     []
   end