blacklight 9.0.0.beta8 → 9.1.0

data/lib/blacklight/configuration.rb

@@ -47,7 +47,12 @@ module Blacklight
       property :header_component, default: Blacklight::HeaderComponent
       property :full_width_layout, default: false
 
-      # bootstrap_version may be set to 4 or 5
+      # @!attribute dark_mode_support
+      # @since v9.1.0
+      # @return [Boolean] Whether to enable the light/dark mode them switcher.
+      # @note Requires Bootstrap v5.3+; see: https://getbootstrap.com/docs/5.3/customize/color-modes/#dark-mode
+      property :dark_mode_support, default: true
+
       bootstrap_version = ENV['BOOTSTRAP_VERSION'].presence || "5"
       property :bootstrap_version, default: /(\d)(?:\.\d){0,2}/.match(bootstrap_version)[1].to_i
 
@@ -104,9 +109,6 @@ module Blacklight
       # @!attribute search_builder_class
       # @return [Class] class for converting Blacklight parameters to request parameters for the repository_class
       property :search_builder_class, default: ::SearchBuilder
-      # @!attribute search_builder_class
-      # @return [Class] class for converting Blacklight parameters to request parameters for the repository_class
-      property :facet_search_builder_class, default: ::FacetSearchBuilder
       # @!attribute response_model
       # model that maps index responses to the blacklight response model
       # @return [Class]
@@ -212,14 +214,14 @@ module Blacklight
 
       # @!attribute action_mapping
       # @since v7.16.0
-      # @return [Hash{Symbol => Blacklight::Configuration::ViewConfig}]
+      # @return [Hash{Symbol => Blacklight::Configuration::ActionConfigMapEntry}]
       property :action_mapping, default: NestedOpenStructWithHashAccess.new(
-        ViewConfig,
-        default: { top_level_config: :index },
-        show: { top_level_config: :show },
-        citation: { parent_config: :show },
-        email_record: { top_level_config: :email },
-        sms_record: { top_level_config: :sms }
+        ActionConfigMapEntry,
+        default: { blacklight_config_property: :index, default: [:index] },
+        show: { blacklight_config_property: :show },
+        citation: { parent_action_key: :show },
+        email_record: { blacklight_config_property: :email },
+        sms_record: { blacklight_config_property: :sms }
       )
 
       # @!attribute sms
@@ -552,7 +554,7 @@ module Blacklight
         conf.klass = klass
       end
     end
-    alias_method :inheritable_copy, :build
+    alias inheritable_copy build
 
     # Get a view configuration for the given view type + action. The effective
     # view configuration is inherited from:
@@ -574,12 +576,7 @@ module Blacklight
         view_type = nil
       end
 
-      @view_config[[view_type, action_name]] ||= if view_type.nil?
-                                                   action_config(action_name)
-                                                 else
-                                                   base_config = action_config(action_name)
-                                                   base_config.merge(view.fetch(view_type, {}))
-                                                 end
+      @view_config[[view_type, action_name]] ||= action_config(action_name, (view.fetch(view_type, nil) if view_type))
     end
 
     # YARD will include inline disabling as docs, cannot do multiline inside @!macro.  AND this must be separate from doc block.
@@ -692,8 +689,8 @@ module Blacklight
       end
     end
 
-    def action_config(action, default: :index)
-      action_config = action_mapping[action]
+    def action_config(action_name, view_type_specific_config, default: :index)
+      action_config = action_mapping[action_name]
       action_config ||= action_mapping[:default]
 
       if action_config.parent_config && action_config.parent_config != :default
@@ -704,9 +701,19 @@ module Blacklight
       end
       action_config = action_config.reverse_merge(action_mapping[:default]) if action_config != action_mapping[:default]
 
-      action_config = action_config.reverse_merge(self[action_config.top_level_config]) if action_config.top_level_config
-      action_config = action_config.reverse_merge(show) if default == :show && action_config.top_level_config != :show
-      action_config.reverse_merge(index)
+      view_config = if action_config.blacklight_config_property
+                      self[action_config.blacklight_config_property]
+                    else
+                      self[default]
+                    end
+
+      view_config = Array(action_config.default - [action_config.blacklight_config_property || default]).inject(view_config) do |config, top_level_config|
+        config.reverse_merge(self[top_level_config])
+      end
+
+      view_config = view_config.merge(view_type_specific_config) if view_type_specific_config
+
+      view_config
     end
   end
 end

data/lib/blacklight/parameters.rb

@@ -79,7 +79,7 @@ module Blacklight
     # Facebook's crawler turns array query parameters into a hash with numeric keys. Once we know
     # the expected parameter structure, we can unmangle those parameters to match our expected values.
     def deep_unmangle_params!(params, permitted_params)
-      permitted_params.select { |p| p.is_a?(Hash) }.each do |permission|
+      permitted_params.grep(Hash).each do |permission|
         permission.each do |key, permitted_value|
           next unless params[key].is_a?(ActionController::Parameters)
 

data/lib/blacklight/routes/searchable.rb

@@ -18,7 +18,7 @@ module Blacklight
         mapper.get "opensearch"
         mapper.get 'suggest', as: 'suggest_index'
         mapper.get "facet/:id", action: 'facet', as: 'facet'
-        mapper.get "facet_suggest/:id/(:query_fragment)", action: 'facet', as: 'facet_suggest', defaults: { only_values: true }
+        mapper.get "facet_suggest/:id", action: 'facet', as: 'facet_suggest', defaults: { only_values: true }
       end
     end
   end

data/lib/blacklight/search_builder.rb

@@ -5,7 +5,54 @@ module Blacklight
   # Blacklight's SearchBuilder converts blacklight request parameters into
   # query parameters appropriate for search index. It does so by evaluating a
   # chain of processing methods to populate a result hash (see {#to_hash}).
-  class SearchBuilder < AbstractSearchBuilder
+  class SearchBuilder
+    class_attribute :default_processor_chain
+    self.default_processor_chain = []
+
+    attr_reader :processor_chain, :blacklight_config
+
+    # @overload initialize(scope)
+    #   @param [Object] scope the scope where the filter methods reside in.
+    # @overload initialize(processor_chain, scope)
+    #   @param [List<Symbol>,TrueClass] processor_chain options a list of filter methods to run or true, to use the default methods
+    #   @param [Object] scope the scope where the filter methods reside in.
+    def initialize(*options, blacklight_config: nil)
+      case options.size
+      when 1
+        @processor_chain = default_processor_chain.dup
+        @scope = options.first
+      when 2
+        @processor_chain, @scope = options
+      else
+        raise ArgumentError, "wrong number of arguments. (#{options.size} for 1..2)"
+      end
+
+      @blacklight_config = blacklight_config || @scope&.blacklight_config
+      @additional_filters = {}
+      @merged_params = {}
+      @reverse_merged_params = {}
+    end
+
+    def search_state
+      @search_state ||= begin
+        search_state_class = @scope.try(:search_state_class) || Blacklight::SearchState
+        @search_state = search_state_class.new({}, blacklight_config, @scope)
+      end
+    end
+
+    def blacklight_params
+      search_state.params
+    end
+    Blacklight.deprecation.deprecate_methods(self, blacklight_params: 'Use search_state.params instead of blacklight_params directly')
+
+    ##
+    # Set the parameters to pass through the processor chain
+    def with(blacklight_params_or_search_state = {})
+      params_will_change!
+      @search_state = blacklight_params_or_search_state.is_a?(Blacklight::SearchState) ? blacklight_params_or_search_state : search_state.reset(blacklight_params_or_search_state)
+      self
+    end
+
     ##
     # Update the :q (query) parameter
     # @param [Hash<Symbol,Object>] conditions the field and values to query on
@@ -13,14 +60,14 @@ module Blacklight
     #    search_builder.where(id: [1,2,3]) # produces: q:"{!lucene}id:(1 OR 2 OR 3)"
     def where(conditions)
       params_will_change!
-      @search_state = @search_state.reset(@search_state.params.merge(q: conditions))
-      @blacklight_params = @search_state.params
+      @search_state = search_state.reset(search_state.params.merge(q: conditions))
       @additional_filters = conditions
       self
     end
 
     ##
     # Append additional processor chain directives
+    # This is used in blacklight_range_limit
     def append(*addl_processor_chain)
       params_will_change!
       builder = self.class.new(processor_chain + addl_processor_chain, scope)
@@ -55,14 +102,103 @@ module Blacklight
       builder
     end
 
+    ##
+    # Merge additional, repository-specific parameters
+    def merge(extra_params, &)
+      if extra_params
+        params_will_change!
+        @merged_params.merge!(extra_params.to_hash, &)
+      end
+      self
+    end
+
+    ##
+    # "Reverse merge" additional, repository-specific parameters
+    def reverse_merge(extra_params, &)
+      if extra_params
+        params_will_change!
+        @reverse_merged_params.reverse_merge!(extra_params.to_hash, &)
+      end
+      self
+    end
+
+    delegate :[], :key?, to: :to_hash
+
+    # a solr query method
+    # @return [Blacklight::Solr::Response] the solr response object
+    def to_hash
+      return @params unless params_need_update?
+
+      @params = processed_parameters
+                .reverse_merge(@reverse_merged_params)
+                .merge(@merged_params)
+                .tap { clear_changes }
+    end
+
+    alias query to_hash
+    alias to_h to_hash
+
+    # The CatalogController #index action uses this.
+    # Solr parameters can come from a number of places. From lowest
+    # precedence to highest:
+    #  1. General defaults in blacklight config (are trumped by)
+    #  2. defaults for the particular search field identified by  params[:search_field] (are trumped by)
+    #  3. certain parameters directly on input HTTP query params
+    #     * not just any parameter is grabbed willy nilly, only certain ones are allowed by HTTP input)
+    #     * for legacy reasons, qt in http query does not over-ride qt in search field definition default.
+    #  4.  extra parameters passed in as argument.
+    #
+    # spellcheck.q will be supplied with the [:q] value unless specifically
+    # specified otherwise.
+    #
+    # Incoming parameter :f is mapped to :fq solr parameter.
+    #
+    # @return a params hash for searching solr.
+    def processed_parameters
+      request.tap do |request_parameters|
+        processor_chain.each do |method_name|
+          send(method_name, request_parameters)
+        end
+      end
+    end
+
+    def default_document_pagination_params
+      { fl: blacklight_config.document_model.unique_key }
+    end
+
+    def for_previous_and_next_documents(index, window = 1)
+      document_pagination_params = blacklight_config.document_pagination_params.dup
+
+      if document_pagination_params.empty?
+        merge(default_document_pagination_params)
+      else
+        merge(document_pagination_params)
+      end
+
+      if index > 0
+        self.start = [index - window, 0].max
+        self.rows = (2 * window) + 1
+      else
+        self.start = 0
+        self.rows = 2 * window
+      end
+
+      self
+    end
+
+    # An undefined value that can be used to detect if a parameter was passed in or not, since nil and false may be valid values for some parameters.
+    UNDEFINED = Object.new.freeze
+
     def start=(value)
+      return if value.nil?
+
       params_will_change!
       @start = value.to_i
     end
 
     # @param [#to_i] value
-    def start(value = nil)
-      if value
+    def start(value = Blacklight::SearchBuilder::UNDEFINED)
+      if value != Blacklight::SearchBuilder::UNDEFINED
         self.start = value
         return self
       end
@@ -71,17 +207,19 @@ module Blacklight
       val = 0 if @start < 0
       val
     end
-    alias_method :padding, :start
+    alias padding start
 
     def page=(value)
+      return if value.nil?
+
       params_will_change!
       @page = value.to_i
       @page = 1 if @page < 1
     end
 
     # @param [#to_i] value
-    def page(value = nil)
-      if value
+    def page(value = Blacklight::SearchBuilder::UNDEFINED)
+      if value != Blacklight::SearchBuilder::UNDEFINED
         self.page = value
         return self
       end
@@ -89,13 +227,15 @@ module Blacklight
     end
 
     def rows=(value)
+      return if value.nil?
+
       params_will_change!
       @rows = [value, blacklight_config.max_per_page].map(&:to_i).min
     end
 
     # @param [#to_i] value
-    def rows(value = nil)
-      if value
+    def rows(value = Blacklight::SearchBuilder::UNDEFINED)
+      if value != Blacklight::SearchBuilder::UNDEFINED
         self.rows = value
         return self
       end
@@ -109,6 +249,34 @@ module Blacklight
 
     alias per rows
 
+    # sets the facet that this query pertains to, for the purpose of facet pagination
+    def facet=(value)
+      params_will_change!
+      @facet = value
+    end
+
+    # @param [Object] value
+    def facet(value = nil)
+      if value
+        self.facet = value
+        return self
+      end
+      @facet
+    end
+
+    def facet_suggestion_query=(value)
+      params_will_change!
+      @facet_suggestion_query = value
+    end
+
+    def facet_suggestion_query(value = nil)
+      if value
+        self.facet_suggestion_query = value
+        return self
+      end
+      @facet_suggestion_query
+    end
+
     # Decode the user provided 'sort' parameter into a sort string that can be
     # passed to the search.  This sanitizes the input by ensuring only
     # configured search values are passed through to the search.
@@ -116,5 +284,35 @@ module Blacklight
     def sort
       search_state.sort_field&.sort
     end
+
+    delegate :search_field, to: :search_state
+
+    private
+
+    def request
+      Blacklight::Solr::Request.new
+    end
+
+    def should_add_field_to_request? _field_name, field
+      field.include_in_request || (field.include_in_request.nil? && blacklight_config.add_field_configuration_to_solr_request)
+    end
+
+    attr_reader :scope
+
+    def params_will_change!
+      @dirty = true
+    end
+
+    def params_changed?
+      !!@dirty
+    end
+
+    def params_need_update?
+      params_changed? || @params.nil?
+    end
+
+    def clear_changes
+      @dirty = false
+    end
   end
 end

data/lib/blacklight/search_state.rb

@@ -37,6 +37,10 @@ module Blacklight
       params[:q]
     end
 
+    def query_boolean_operator
+      params[:op]
+    end
+
     def clause_params
       params[:clause] || {}
     end

data/lib/blacklight/solr/request.rb

@@ -2,7 +2,7 @@
 
 class Blacklight::Solr::InvalidParameter < ArgumentError; end
 
-class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess
+class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess # rubocop:disable Style/OneClassPerFile
   def initialize(constructor = {})
     if constructor.is_a?(Hash)
       super()
@@ -52,6 +52,13 @@ class Blacklight::Solr::Request < ActiveSupport::HashWithIndifferentAccess
     self['fq'] << query
   end
 
+  # Filter the results to a specific set of values in the given field.
+  # @param [String] field
+  # @param [Array<String>] values
+  def append_ids_filter(field, values)
+    append_filter_query("{!terms f=#{field}}#{Array(values).join(',')}")
+  end
+
   def append_facet_fields(values)
     self['facet.field'] ||= []
     self['facet.field'] += Array(values)

data/lib/blacklight/solr/response/group_response.rb

@@ -11,7 +11,7 @@ class Blacklight::Solr::Response::GroupResponse
     @response = response
   end
 
-  alias_method :group_field, :key
+  alias group_field key
 
   def groups
     @groups ||= group["groups"].map do |g|

data/lib/blacklight/solr/response/spelling.rb

@@ -53,14 +53,14 @@ module Blacklight::Solr::Response::Spelling
               #   suggestion =>  [{ frequency =>, word => }] # for extended results
               #   suggestion => ['word'] # for non-extended results
               orig_freq = term_info['origFreq']
-              if term_info['suggestion'].first.is_a?(Hash)
-                word_suggestions << term_info['suggestion'].map do |suggestion|
-                  suggestion['word'] if suggestion['freq'] > orig_freq
-                end
-              else
-                # only extended suggestions have frequency so we just return all suggestions
-                word_suggestions << term_info['suggestion']
-              end
+              word_suggestions << if term_info['suggestion'].first.is_a?(Hash)
+                                    term_info['suggestion'].map do |suggestion|
+                                      suggestion['word'] if suggestion['freq'] > orig_freq
+                                    end
+                                  else
+                                    # only extended suggestions have frequency so we just return all suggestions
+                                    term_info['suggestion']
+                                  end
             end
           end
         end

data/lib/blacklight/solr/response.rb

@@ -18,7 +18,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   def initialize(data, request_params, options = {})
     @search_builder = request_params if request_params.is_a?(Blacklight::SearchBuilder)
 
-    super(force_to_utf8(ActiveSupport::HashWithIndifferentAccess.new(data)))
+    super(ActiveSupport::HashWithIndifferentAccess.new(data))
     @request_params = ActiveSupport::HashWithIndifferentAccess.new(request_params)
     self.blacklight_config = options[:blacklight_config]
     self.options = options
@@ -31,7 +31,7 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   def documents
     @documents ||= (response['docs'] || []).collect { |doc| document_factory.build(doc, self, options) }
   end
-  alias_method :docs, :documents
+  alias docs documents
 
   def grouped
     @groups ||= self["grouped"].map do |field, group|
@@ -61,23 +61,4 @@ class Blacklight::Solr::Response < ActiveSupport::HashWithIndifferentAccess
   def export_formats
     documents.map { |x| x.export_formats.keys }.flatten.uniq
   end
-
-  private
-
-  def force_to_utf8(value)
-    case value
-    when Hash
-      value.each { |k, v| value[k] = force_to_utf8(v) }
-    when Array
-      value.each { |v| force_to_utf8(v) }
-    when String
-      if value.encoding == Encoding::UTF_8
-        value
-      else
-        Blacklight.logger&.warn "Found a non utf-8 value in Blacklight::Solr::Response. \"#{value}\" Encoding is #{value.encoding}"
-        value.dup.force_encoding('UTF-8')
-      end
-    end
-    value
-  end
 end

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
 
 module Blacklight::Solr
+  # This depends on being imported into a class that extends AbstractSearchBuilder
   module SearchBuilderBehavior
     extend ActiveSupport::Concern
 
     included do
       self.default_processor_chain = [
-        :default_solr_parameters, :add_search_field_default_parameters,
-        :add_query_to_solr, :add_facet_fq_to_solr,
-        :add_facetting_to_solr, :add_solr_fields_to_query, :add_paging_to_solr,
-        :add_sorting_to_solr, :add_group_config_to_solr,
-        :add_adv_search_clauses, :add_facets_for_advanced_search_form,
+        :default_solr_parameters,
+        :add_search_field_default_parameters,
+        :add_query_to_solr,
+        :add_facet_fq_to_solr,
+        :add_facetting_to_solr,
+        :add_solr_fields_to_query,
+        :add_paging_to_solr,
+        :add_sorting_to_solr,
+        :add_group_config_to_solr,
+        :add_adv_search_clauses,
+        :add_facets_for_advanced_search_form,
+        :add_facet_paging_to_solr,
+        :add_facet_suggestion_parameters,
         :add_additional_filters
       ]
     end
@@ -93,7 +102,7 @@ module Blacklight::Solr
 
     # Transform "clause" parameters into the Solr JSON Query DSL
     def add_adv_search_clauses(solr_parameters)
-      return if search_state.clause_params.blank?
+      return if search_state.clause_params.blank? || search_state.clause_params.all? { |_k, v| v[:query].blank? }
 
       # We need to specify lucene as the top-level defType when using JSON Query DSL in Solr versions
       # between 7.2.0 & 9.4.0. After 9.4.0 this is no longer necessary, but also not harmful to include.
@@ -103,7 +112,7 @@ module Blacklight::Solr
       solr_parameters[:spellcheck] = 'false'
 
       defaults = { must: [], must_not: [], should: [] }
-      default_op = blacklight_params[:op]&.to_sym || :must
+      default_op = search_state.query_boolean_operator&.to_sym || :must
       solr_parameters[:mm] = 1 if default_op == :should && search_state.clause_params.values.any? { |clause| }
 
       search_state.clause_params.each_value do |clause|
@@ -191,7 +200,7 @@ module Blacklight::Solr
         if facet.pivot
           solr_parameters.append_facet_pivot with_ex_local_param(facet.ex, facet.pivot.join(","))
         elsif facet.query
-          solr_parameters.append_facet_query facet.query.values.map { |x| with_ex_local_param(facet.ex, x[:fq]) }
+          solr_parameters.append_facet_query(facet.query.values.map { |x| with_ex_local_param(facet.ex, x[:fq]) })
         else
           solr_parameters.append_facet_fields with_ex_local_param(facet.ex, facet.field)
         end
@@ -232,8 +241,6 @@ module Blacklight::Solr
     # copy paging params from BL app over to solr, changing
     # app level per_page and page to Solr rows and start.
     def add_paging_to_solr(solr_params)
-      rows(solr_params[:rows] || 10) if rows.nil?
-
       solr_params[:rows] = rows
 
       solr_params[:start] = start if start.nonzero?
@@ -250,6 +257,48 @@ module Blacklight::Solr
       solr_parameters[:group] = false if search_state.filter(grouped_key_for_results).any?
     end
 
+    def add_facet_paging_to_solr(solr_params)
+      return if facet.blank?
+
+      facet_config = blacklight_config.facet_fields[facet]
+
+      solr_params[:rows] = 0
+
+      limit = if solr_params["facet.limit"]
+                solr_params["facet.limit"].to_i
+              else
+                facet_config.fetch(:more_limit, blacklight_config.default_more_limit)
+              end
+
+      page = search_state.facet_page
+      sort = search_state.facet_sort
+      prefix = search_state.facet_prefix
+      offset = (page - 1) * limit
+
+      if facet_config.json
+        add_solr_facet_json_params(solr_parameters, facet, facet_config, limit: limit + 1, offset: offset, sort: sort, prefix: prefix)
+        return
+      end
+
+      # Now override with our specific things for fetching facet values
+      facet_ex = facet_config.respond_to?(:ex) ? facet_config.ex : nil
+      solr_params[:'facet.field'] = with_ex_local_param(facet_ex, facet_config.field)
+
+      # Need to set as f.facet_field.facet.* to make sure we
+      # override any field-specific default in the solr request handler.
+      solr_params[:"f.#{facet_config.field}.facet.limit"] = limit + 1
+      solr_params[:"f.#{facet_config.field}.facet.offset"] = offset
+      solr_params[:"f.#{facet_config.field}.facet.sort"] = sort if sort
+      solr_params[:"f.#{facet_config.field}.facet.prefix"] = prefix if prefix
+    end
+
+    def add_facet_suggestion_parameters(solr_params)
+      return if facet.blank? || facet_suggestion_query.blank?
+
+      solr_params[:'facet.contains'] = facet_suggestion_query[0..50]
+      solr_params[:'facet.contains.ignoreCase'] = true
+    end
+
     def with_ex_local_param(ex, value)
       if ex
         "{!ex=#{ex}}#{value}"
@@ -318,12 +367,6 @@ module Blacklight::Solr
       end
     end
 
-    def search_state
-      return super if defined?(super)
-
-      @search_state ||= Blacklight::SearchState.new(blacklight_params, blacklight_config)
-    end
-
     def add_search_field_query_builder_params(solr_parameters)
       q, additional_parameters = search_field.query_builder.call(self, search_field, solr_parameters)
 

data/lib/blacklight.rb

@@ -85,7 +85,7 @@ module Blacklight
                         else
                           YAML.safe_load(blacklight_erb, [], [], true)
                         end
-    rescue => e
+    rescue StandardError => e
       raise("#{blacklight_config_file} was found, but could not be parsed.\n#{e.inspect}")
     end
 
@@ -122,6 +122,6 @@ module Blacklight
   end
 
   def self.deprecation
-    @deprecation ||= ActiveSupport::Deprecation.new('9.0', 'Blacklight')
+    @deprecation ||= ActiveSupport::Deprecation.new('10.0', 'Blacklight')
   end
 end

data/lib/generators/blacklight/assets/importmap_generator.rb

@@ -8,7 +8,7 @@ module Blacklight
       def import_javascript_assets
         append_to_file 'config/importmap.rb' do
           <<~CONTENT
-            pin "@github/auto-complete-element", to: "https://cdn.skypack.dev/@github/auto-complete-element"
+            pin "@github/auto-complete-element", to: "https://cdn.jsdelivr.net/npm/@github/auto-complete-element@3.8.0/+esm"
             pin "@popperjs/core", to: "https://ga.jspm.io/npm:@popperjs/core@2.11.6/dist/umd/popper.min.js"
             pin "bootstrap", to: "https://ga.jspm.io/npm:bootstrap@#{(defined?(Bootstrap) && Bootstrap::VERSION) || '5.3.5'}/dist/js/bootstrap.js"
           CONTENT
@@ -49,7 +49,7 @@ module Blacklight
         else
           append_to_file 'app/assets/stylesheets/application.css' do
             <<~CONTENT
-              @import url(https://cdn.jsdelivr.net/npm/bootstrap@5.3.5/dist/css/bootstrap.min.css);
+              @import url(https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css);
               @import url("blacklight.css");
             CONTENT
           end