blacklight 6.14.0 → 7.0.0

data/app/helpers/blacklight/render_partials_helper_behavior.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+module Blacklight::RenderPartialsHelperBehavior
+  ##
+  # Render the document index view
+  #
+  # @param [Array<SolrDocument>] documents list of documents to render
+  # @param [Hash] locals to pass to the render call
+  # @return [String]
+  def render_document_index documents = nil, locals = {}
+    documents ||= @response.documents
+    render_document_index_with_view(document_index_view_type, documents, locals)
+  end
+
+  ##
+  # Render the document index for a grouped response
+  def render_grouped_document_index
+    render 'catalog/group'
+  end
+
+  ##
+  # Return the list of partials for a given solr document
+  # @param [SolrDocument] doc solr document to render partials for
+  # @param [Array<String>] partials list of partials to render
+  # @param [Hash] locals local variables to pass to the render call
+  # @return [String]
+  def render_document_partials(doc, partials = [], locals = {})
+    safe_join(partials.map do |action_name|
+      render_document_partial(doc, action_name, locals)
+    end, "\n")
+  end
+
+  ##
+  # Given a doc and a base name for a partial, this method will attempt to render
+  # an appropriate partial based on the document format and view type.
+  #
+  # If a partial that matches the document format is not found,
+  # render a default partial for the base name.
+  #
+  # @see #document_partial_path_templates
+  #
+  # @param [SolrDocument] doc
+  # @param [String] base_name base name for the partial
+  # @param [Hash] locals local variables to pass through to the partials
+  def render_document_partial(doc, base_name, locals = {})
+    format = document_partial_name(doc, base_name)
+
+    view_type = document_index_view_type
+    template = cached_view ['show', view_type, base_name, format].join('_') do
+      find_document_show_template_with_view(view_type, base_name, format, locals)
+    end
+    if template
+      template.render(self, locals.merge(document: doc))
+    else
+      ''
+    end
+  end
+
+  ##
+  # Render the document index for the given view type with the
+  # list of documents.
+  #
+  # This method will interpolate the list of templates with
+  # the current view, and gracefully handles missing templates.
+  #
+  # @see #document_index_path_templates
+  #
+  # @param [String] view type
+  # @param [Array<SolrDocument>] documents list of documents to render
+  # @param [Hash] locals to pass to the render call
+  # @return [String]
+  def render_document_index_with_view view, documents, locals = {}
+    template = cached_view ['index', view].join('_') do
+      find_document_index_template_with_view(view, locals)
+    end
+
+    if template
+      template.render(self, locals.merge(documents: documents))
+    else
+      ''
+    end
+  end
+
+  ##
+  # A list of document partial templates to attempt to render
+  #
+  # @see #render_document_index_with_view
+  # @return [Array<String>]
+  def document_index_path_templates
+    # first, the legacy template names for backwards compatbility
+    # followed by the new, inheritable style
+    # finally, a controller-specific path for non-catalog subclasses
+    @document_index_path_templates ||= [
+      "document_%{index_view_type}",
+      "catalog/document_%{index_view_type}",
+      "catalog/document_list"
+    ]
+  end
+
+  ##
+  # Return a normalized partial name for rendering a single document
+  #
+  # @param [SolrDocument] document
+  # @param [Symbol] base_name base name for the partial
+  # @return [String]
+  def document_partial_name(document, base_name = nil)
+    view_config = blacklight_config.view_config(:show)
+
+    display_type = if base_name && view_config.key?(:"#{base_name}_display_type_field")
+                     document[view_config[:"#{base_name}_display_type_field"]]
+                   end
+
+    display_type ||= document[view_config.display_type_field]
+
+    display_type ||= 'default'
+
+    type_field_to_partial_name(document, display_type)
+  end
+
+  private
+
+  ##
+  # Return a partial name for rendering a document
+  # this method can be overridden in order to transform the value
+  #   (e.g. 'PdfBook' => 'pdf_book')
+  #
+  # @param [SolrDocument] document
+  # @param [String, Array] display_type a value suggestive of a partial
+  # @return [String] the name of the partial to render
+  # @example
+  #  type_field_to_partial_name(['a book-article'])
+  #  => 'a_book_article'
+  def type_field_to_partial_name(_document, display_type)
+    # using "_" as sep. to more closely follow the views file naming conventions
+    # parameterize uses "-" as the default sep. which throws errors
+    underscore = '_'
+    Array(display_type).join(' ').tr('-', underscore).parameterize(separator: underscore)
+  end
+
+  ##
+  # A list of document partial templates to try to render for a document
+  #
+  # The partial names will be interpolated with the following variables:
+  #   - action_name: (e.g. index, show)
+  #   - index_view_type: (the current view type, e.g. list, gallery)
+  #   - format: the document's format (e.g. book)
+  #
+  # @see #render_document_partial
+  def document_partial_path_templates
+    # first, the legacy template names for backwards compatbility
+    # followed by the new, inheritable style
+    # finally, a controller-specific path for non-catalog subclasses
+    @partial_path_templates ||= [
+      "%{action_name}_%{index_view_type}_%{format}",
+      "%{action_name}_%{index_view_type}_default",
+      "%{action_name}_%{format}",
+      "%{action_name}_default",
+      "%{action_name}",
+      "catalog/%{action_name}_%{format}",
+      "catalog/_%{action_name}_partials/%{format}",
+      "catalog/_%{action_name}_partials/default"
+    ]
+  end
+
+  def find_document_show_template_with_view view_type, base_name, format, locals
+    document_partial_path_templates.each do |str|
+      partial = format(str, action_name: base_name, format: format, index_view_type: view_type)
+      logger.debug "Looking for document partial #{partial}"
+      template = lookup_context.find_all(partial, lookup_context.prefixes + [""], true, locals.keys + [:document], {}).first
+      return template if template
+    end
+    nil
+  end
+
+  def find_document_index_template_with_view view_type, locals
+    document_index_path_templates.each do |str|
+      partial = format(str, index_view_type: view_type)
+      logger.debug "Looking for document index partial #{partial}"
+      template = lookup_context.find_all(partial, lookup_context.prefixes + [""], true, locals.keys + [:documents], {}).first
+      return template if template
+    end
+    nil
+  end
+
+  ##
+  # @param key fetches or writes data to a cache, using the given key.
+  # @yield the block to evaluate (and cache) if there is a cache miss
+  def cached_view key
+    @view_cache ||= {}
+    if @view_cache.key?(key)
+      @view_cache[key]
+    else
+      @view_cache[key] = yield
+    end
+  end
+end

data/app/helpers/blacklight/search_history_constraints_helper_behavior.rb

@@ -8,8 +8,8 @@
 module Blacklight::SearchHistoryConstraintsHelperBehavior
   # Simpler textual version of constraints, used on Search History page.
   # Theoretically can may be DRY'd up with results page render_constraints,
-  # maybe even using the very same HTML with different CSS? 
-  # But too tricky for now, too many changes to existing CSS. TODO.  
+  # maybe even using the very same HTML with different CSS?
+  # But too tricky for now, too many changes to existing CSS. TODO.
   def render_search_to_s(params)
     render_search_to_s_q(params) +
     render_search_to_s_filters(params)
@@ -22,7 +22,7 @@ module Blacklight::SearchHistoryConstraintsHelperBehavior
 
     label = label_for_search_field(params[:search_field]) unless default_search_field && params[:search_field] == default_search_field[:key]
 
-    render_search_to_s_element(label , render_filter_value(params['q']) )
+    render_search_to_s_element(label, render_filter_value(params['q']))
   end
 
   ##
@@ -32,24 +32,30 @@ module Blacklight::SearchHistoryConstraintsHelperBehavior
 
     safe_join(params[:f].collect do |facet_field, value_list|
       render_search_to_s_element(facet_field_label(facet_field),
-        safe_join(value_list.collect do |value|
-          render_filter_value(value, facet_field)
-        end, content_tag(:span, " #{t('blacklight.and')} ", :class =>'filterSeparator')))    
+                                 safe_join(value_list.collect do |value|
+                                   render_filter_value(value, facet_field)
+                                 end,
+                                           content_tag(:span, " #{t('blacklight.and')} ", class: 'filter-separator')))
     end, " \n ")
   end
 
   # value can be Array, in which case elements are joined with
   # 'and'.   Pass in option :escape_value => false to pass in pre-rendered
-  # html for value. key with escape_key if needed.  
-  def render_search_to_s_element(key, value, options = {})
-    content_tag(:span, render_filter_name(key) + content_tag(:span, value, :class => 'filterValues'), :class => 'constraint')
+  # html for value. key with escape_key if needed.
+  def render_search_to_s_element(key, value, _options = {})
+    content_tag(:span,
+                render_filter_name(key) + content_tag(:span, value, class: 'filter-values'),
+                class: 'constraint')
   end
 
   ##
   # Render the name of the facet
   def render_filter_name name
     return "".html_safe if name.blank?
-    content_tag(:span, t('blacklight.search.filters.label', :label => name), :class => 'filterName')
+
+    content_tag(:span,
+                t('blacklight.search.filters.label', label: name),
+                class: 'filter-name')
   end
 
   ##
@@ -57,6 +63,8 @@ module Blacklight::SearchHistoryConstraintsHelperBehavior
   def render_filter_value value, key = nil
     display_value = value
     display_value = facet_display_value(key, value) if key
-    content_tag(:span, h(display_value), :class => 'filterValue')
+    content_tag(:span,
+                h(display_value),
+                class: 'filter-value')
   end
 end

data/app/helpers/blacklight/suggest_helper_behavior.rb

@@ -7,5 +7,6 @@ module Blacklight
       blacklight_config.autocomplete_enabled.present? &&
         blacklight_config.autocomplete_path.present?
     end
+    deprecation_deprecate autocomplete_enabled?: "use SearchBarPresenter#autocomplete_enabled?"
   end
 end

data/app/helpers/blacklight/url_helper_behavior.rb

@@ -2,53 +2,61 @@
 ##
 # URL helper methods
 module Blacklight::UrlHelperBehavior
-  include Blacklight::DeprecatedUrlHelperBehavior
-
-  ##
-  # Extension point for downstream applications
-  # to provide more interesting routing to
-  # documents
   def url_for_document(doc, options = {})
     search_state.url_for_document(doc, options)
   end
 
-  # link_to_document(doc, 'VIEW', :counter => 3)
-  # Use the catalog_path RESTful route to create a link to the show page for a specific item.
+  # Uses the catalog_path route to create a link to the show page for an item.
   # catalog_path accepts a hash. The solr query params are stored in the session,
   # so we only need the +counter+ param here. We also need to know if we are viewing to document as part of search results.
   # TODO: move this to the IndexPresenter
-  def link_to_document(doc, field_or_opts = nil, opts={:counter => nil})
-    if field_or_opts.is_a? Hash
-      opts = field_or_opts
-    else
-      field = field_or_opts
-    end
+  # @param doc [SolrDocument] the document
+  # @param field_or_opts [Hash, String] either a string to render as the link text or options
+  # @param opts [Hash] the options to create the link with
+  # @option opts [Number] :counter (nil) the count to set in the session (for paging through a query result)
+  # @example Passing in an image
+  #   link_to_document(doc, '<img src="thumbnail.png">', counter: 3) #=> "<a href=\"catalog/123\" data-tracker-href=\"/catalog/123/track?counter=3&search_id=999\"><img src="thumbnail.png"></a>
+  # @example With the default document link field
+  #   link_to_document(doc, counter: 3) #=> "<a href=\"catalog/123\" data-tracker-href=\"/catalog/123/track?counter=3&search_id=999\">My Title</a>
+  def link_to_document(doc, field_or_opts = nil, opts = { counter: nil })
+    label = case field_or_opts
+            when NilClass
+              index_presenter(doc).label document_show_link_field(doc), opts
+            when Hash
+              opts = field_or_opts
+              index_presenter(doc).label document_show_link_field(doc), opts
+            when Proc, Symbol
+              Deprecation.warn(self, "passing a #{field_or_opts.class} to link_to_document is deprecated and will be removed in Blacklight 8")
+              Deprecation.silence(Blacklight::IndexPresenter) do
+                index_presenter(doc).label field_or_opts, opts
+              end
+            else # String
+              field_or_opts
+            end
 
-    field ||= document_show_link_field(doc)
-    label = index_presenter(doc).label field, opts
     link_to label, url_for_document(doc), document_link_params(doc, opts)
   end
 
   def document_link_params(doc, opts)
     session_tracking_params(doc, opts[:counter]).deep_merge(opts.except(:label, :counter))
   end
-  protected :document_link_params
+  private :document_link_params
 
   ##
   # Link to the previous document in the current search context
   def link_to_previous_document(previous_document)
-    link_opts = session_tracking_params(previous_document, search_session['counter'].to_i - 1).merge(:class => "previous", :rel => 'prev')
+    link_opts = session_tracking_params(previous_document, search_session['counter'].to_i - 1).merge(class: "previous", rel: 'prev')
     link_to_unless previous_document.nil?, raw(t('views.pagination.previous')), url_for_document(previous_document), link_opts do
-      content_tag :span, raw(t('views.pagination.previous')), :class => 'previous'
+      content_tag :span, raw(t('views.pagination.previous')), class: 'previous'
     end
   end
 
   ##
   # Link to the next document in the current search context
   def link_to_next_document(next_document)
-    link_opts = session_tracking_params(next_document, search_session['counter'].to_i + 1).merge(:class => "next", :rel => 'next')
+    link_opts = session_tracking_params(next_document, search_session['counter'].to_i + 1).merge(class: "next", rel: 'next')
     link_to_unless next_document.nil?, raw(t('views.pagination.next')), url_for_document(next_document), link_opts do
-      content_tag :span, raw(t('views.pagination.next')), :class => 'next'
+      content_tag :span, raw(t('views.pagination.next')), class: 'next'
     end
   end
 
@@ -66,20 +74,21 @@ module Blacklight::UrlHelperBehavior
       return {}
     end
 
-    { data: {:'context-href' => path } }
+    { data: { :'context-href' => path } }
   end
-  protected :session_tracking_params
+  private :session_tracking_params
 
   ##
   # Get the URL for tracking search sessions across pages using polymorphic routing
   def session_tracking_path document, params = {}
-    return if document.nil?
+    return if document.nil? || controller_name == 'bookmarks'
 
-    if respond_to?(controller_tracking_method)
-      send(controller_tracking_method, params.merge(id: document))
-    else
-      blacklight.track_search_context_path(params.merge(id: document))
+    if main_app.respond_to?(controller_tracking_method)
+      return main_app.public_send(controller_tracking_method, params.merge(id: document))
     end
+
+    raise "Unable to find #{controller_tracking_method} route helper. " \
+    "Did you add `concerns :searchable` routing mixin to your `config/routes.rb`?"
   end
 
   def controller_tracking_method
@@ -101,7 +110,7 @@ module Blacklight::UrlHelperBehavior
   # Get the path to the search action with any parameters (e.g. view type)
   # that should be persisted across search sessions.
   def start_over_path query_params = params
-    h = { }
+    h = {}
     current_index_view_type = document_index_view_type(query_params)
     h[:view] = current_index_view_type unless current_index_view_type == default_document_index_view_type
 
@@ -112,23 +121,23 @@ module Blacklight::UrlHelperBehavior
   # @example
   #   link_back_to_catalog(label: 'Back to Search')
   #   link_back_to_catalog(label: 'Back to Search', route_set: my_engine)
-  def link_back_to_catalog(opts={:label=>nil})
+  def link_back_to_catalog(opts = { label: nil })
     scope = opts.delete(:route_set) || self
     query_params = search_state.reset(current_search_session.try(:query_params)).to_hash
 
     if search_session['counter']
-      per_page = (search_session['per_page'] || default_per_page).to_i
+      per_page = (search_session['per_page'] || blacklight_config.default_per_page).to_i
       counter = search_session['counter'].to_i
 
-      query_params[:per_page] = per_page unless search_session['per_page'].to_i == default_per_page
-      query_params[:page] = ((counter - 1)/ per_page) + 1
+      query_params[:per_page] = per_page unless search_session['per_page'].to_i == blacklight_config.default_per_page
+      query_params[:page] = ((counter - 1) / per_page) + 1
     end
 
     link_url = if query_params.empty?
-      search_action_path(only_path: true)
-    else
-      scope.url_for(query_params)
-    end
+                 search_action_path(only_path: true)
+               else
+                 scope.url_for(query_params)
+               end
     label = opts.delete(:label)
 
     if link_url =~ /bookmarks/
@@ -153,11 +162,11 @@ module Blacklight::UrlHelperBehavior
     search_state.add_facet_params_and_redirect(group.field, group.key)
   end
 
-  # A URL to refworks export, with an embedded callback URL to this app. 
-  # the callback URL is to bookmarks#export, which delivers a list of 
+  # A URL to refworks export, with an embedded callback URL to this app.
+  # the callback URL is to bookmarks#export, which delivers a list of
   # user's bookmarks in 'refworks marc txt' format -- we tell refworks
-  # to expect that format. 
+  # to expect that format.
   def bookmarks_export_url(format, params = {})
-    bookmarks_url(params.merge(format: format, encrypted_user_id: encrypt_user_id(current_or_guest_user.id) ))
+    bookmarks_url(params.merge(format: format, encrypted_user_id: encrypt_user_id(current_or_guest_user.id)))
   end
 end

data/app/{assets/javascripts → javascript}/blacklight/autocomplete.js

@@ -1,4 +1,5 @@
 /*global Bloodhound */
+import Bloodhound from 'typeahead.js/dist/bloodhound.js'
 
 Blacklight.onLoad(function() {
   'use strict';
@@ -9,7 +10,7 @@ Blacklight.onLoad(function() {
       return;
     }
     var suggestUrl = $el.data().autocompletePath;
-    
+
     var terms = new Bloodhound({
       datumTokenizer: Bloodhound.tokenizers.obj.whitespace('value'),
       queryTokenizer: Bloodhound.tokenizers.whitespace,
@@ -18,7 +19,7 @@ Blacklight.onLoad(function() {
         wildcard: '%QUERY'
       }
     });
-    
+
     terms.initialize();
 
     $el.typeahead({

data/app/javascript/blacklight/bookmark_toggle.js

@@ -0,0 +1,25 @@
+(function($) {
+    //change form submit toggle to checkbox
+    Blacklight.doBookmarkToggleBehavior = function() {
+      if (typeof Blacklight.do_bookmark_toggle_behavior == 'function') {
+        console.warn("do_bookmark_toggle_behavior is deprecated. Use doBookmarkToggleBehavior instead.");
+        return Blacklight.do_bookmark_toggle_behavior();
+      }
+      $(Blacklight.doBookmarkToggleBehavior.selector).blCheckboxSubmit({
+         // cssClass is added to elements added, plus used for id base
+         cssClass: 'toggle-bookmark',
+         success: function(checked, response) {
+           if (response.bookmarks) {
+             $('[data-role=bookmark-counter]').text(response.bookmarks.count);
+           }
+         }
+      });
+    };
+    Blacklight.doBookmarkToggleBehavior.selector = 'form.bookmark-toggle';
+
+Blacklight.onLoad(function() {
+  Blacklight.doBookmarkToggleBehavior();
+});
+
+
+})(jQuery);

data/app/javascript/blacklight/checkbox_submit.js

@@ -0,0 +1,134 @@
+/* A JQuery plugin (should this be implemented as a widget instead? not sure)
+   that will convert a "toggle" form, with single submit button to add/remove
+   something, like used for Bookmarks, into an AJAXy checkbox instead.
+
+   Apply to a form. Does require certain assumption about the form:
+    1) The same form 'action' href must be used for both ADD and REMOVE
+       actions, with the different being the hidden input name="_method"
+       being set to "put" or "delete" -- that's the Rails method to pretend
+       to be doing a certain HTTP verb. So same URL, PUT to add, DELETE
+       to remove. This plugin assumes that.
+
+       Plus, the form this is applied to should provide a data-doc-id
+       attribute (HTML5-style doc-*) that contains the id/primary key
+       of the object in question -- used by plugin for a unique value for
+       DOM id's.
+
+  Uses HTML for a checkbox compatible with Bootstrap 3.
+
+   Pass in options for your class name and labels:
+   $("form.something").blCheckboxSubmit({
+        //cssClass is added to elements added, plus used for id base
+        cssClass: "toggle_my_kinda_form",
+        error: function() {
+          #optional callback
+        },
+        success: function(after_success_check_state) {
+          #optional callback
+        }
+   });
+*/
+(function($) {
+    $.fn.blCheckboxSubmit = function(argOpts) {
+      this.each(function() {
+        var options = $.extend({}, $.fn.blCheckboxSubmit.defaults, argOpts);
+
+
+        var form = $(this);
+        form.children().hide();
+        //We're going to use the existing form to actually send our add/removes
+        //This works conveneintly because the exact same action href is used
+        //for both bookmarks/$doc_id.  But let's take out the irrelevant parts
+        //of the form to avoid any future confusion.
+        form.find('input[type=submit]').remove();
+
+        //View needs to set data-doc-id so we know a unique value
+        //for making DOM id
+        var uniqueId = form.attr('data-doc-id') || Math.random();
+        // if form is currently using method delete to change state,
+        // then checkbox is currently checked
+        var checked = (form.find('input[name=_method][value=delete]').length != 0);
+
+        var checkbox = $('<input type="checkbox">')
+          .addClass( options.cssClass )
+          .attr('id', options.cssClass + '_' + uniqueId);
+        var label = $('<label>')
+          .addClass( options.cssClass )
+          .attr('for', options.cssClass + '_' + uniqueId)
+          .attr('title', form.attr('title') || '');
+        var span = $('<span>');
+
+        label.append(checkbox);
+        label.append(' ');
+        label.append(span);
+
+        var checkboxDiv = $('<div class="checkbox" />')
+          .addClass(options.cssClass)
+          .append(label);
+
+        function updateStateFor(state) {
+            checkbox.prop('checked', state);
+            label.toggleClass('checked', state);
+            if (state) {
+               //Set the Rails hidden field that fakes an HTTP verb
+               //properly for current state action.
+               form.find('input[name=_method]').val('delete');
+               span.text(form.attr('data-present'));
+            } else {
+               form.find('input[name=_method]').val('put');
+               span.text(form.attr('data-absent'));
+            }
+          }
+
+        form.append(checkboxDiv);
+        updateStateFor(checked);
+
+        checkbox.click(function() {
+            span.text(form.attr('data-inprogress'));
+            label.attr('disabled', 'disabled');
+            checkbox.attr('disabled', 'disabled');
+
+            $.ajax({
+                url: form.attr('action'),
+                dataType: 'json',
+                type: form.attr('method').toUpperCase(),
+                data: form.serialize(),
+                error: function() {
+                   label.removeAttr('disabled');
+                   checkbox.removeAttr('disabled');
+                   options.error.call();
+                },
+                success: function(data, status, xhr) {
+                  //if app isn't running at all, xhr annoyingly
+                  //reports success with status 0.
+                  if (xhr.status != 0) {
+                    checked = ! checked;
+                    updateStateFor(checked);
+                    label.removeAttr('disabled');
+                    checkbox.removeAttr('disabled');
+                    options.success.call(form, checked, xhr.responseJSON);
+                  } else {
+                    label.removeAttr('disabled');
+                    checkbox.removeAttr('disabled');
+                    options.error.call();
+                  }
+                }
+            });
+
+            return false;
+        }); //checkbox.click
+
+
+      }); //this.each
+      return this;
+    };
+
+  $.fn.blCheckboxSubmit.defaults =  {
+            //cssClass is added to elements added, plus used for id base
+            cssClass: 'blCheckboxSubmit',
+            error: function() {
+              alert("Error");
+            },
+            success: function() {} //callback
+  };
+})(jQuery);

data/app/{assets/javascripts → javascript}/blacklight/collapsable.js

@@ -2,7 +2,7 @@
   Blacklight.onLoad(function() {
     // when clicking on a link that toggles the collapsing behavior, don't do anything
     // with the hash or the page could jump around.
-    $(document).on("click", "a[data-toggle=collapse][href='#'], [data-toggle=collapse] a[href='#']", function(event) {
+    $(document).on('click', 'a[data-toggle=collapse][href="#"], [data-toggle=collapse] a[href="#"]', function(event) {
       event.preventDefault();
     });
   });

data/app/{assets/javascripts → javascript}/blacklight/core.js

@@ -19,21 +19,23 @@ Blacklight = function() {
           listeners.push('turbolinks:load');
         } else {
           // Turbolinks < 5
-          listeners.push('page:load', 'ready');
+          listeners.push('page:load', 'DOMContentLoaded');
         }
       } else {
-        listeners.push('ready');
+        listeners.push('DOMContentLoaded');
       }
 
-      return listeners.join(' ');
+      return listeners;
     }
   };
 }();
 
 // turbolinks triggers page:load events on page transition
-// If app isn't using turbolinks, this event will never be triggered, no prob. 
-$(document).on(Blacklight.listeners(), function() {
-  Blacklight.activate();  
-});
-
+// If app isn't using turbolinks, this event will never be triggered, no prob.
+Blacklight.listeners().forEach(function(listener) {
+  document.addEventListener(listener, function() {
+    Blacklight.activate()
+  })
+})
 
+$('.no-js').removeClass('no-js').addClass('js');