pagy 8.0.0 → 9.0.0

data/lib/pagy/extras/gearbox.rb

@@ -3,51 +3,52 @@
 
 class Pagy # :nodoc:
   DEFAULT[:gearbox_extra] = true # extra enabled by default
-  DEFAULT[:gearbox_items] = [15, 30, 60, 100]
+  DEFAULT[:gearbox_limit] = [15, 30, 60, 100]
 
-  # Automatically change the number of items per page depending on the page number
-  # accepts an array as the :gearbox_items variable, that will determine the items for the first pages
+  # Automatically change the limit depending on the page number
+  # accepts an array as the :gearbox_limit variable, that will determine the limit for the first pages
   module GearboxExtra
-    # Setup @items based on the :gearbox_items variable
-    def setup_items_var
-      return super if !@vars[:gearbox_extra] || @vars[:items_extra]
+    # Assign @limit based on the :gearbox_limit variable
+    def assign_limit
+      return super if !@vars[:gearbox_extra] || @vars[:limit_extra]
 
-      gearbox_items = @vars[:gearbox_items]
-      raise VariableError.new(self, :gearbox_items, 'to be an Array of positives', gearbox_items) \
-            unless gearbox_items.is_a?(Array) && gearbox_items.all? { |num| num.positive? rescue false } # rubocop:disable Style/RescueModifier
+      gears = @vars[:gearbox_limit]
+      raise VariableError.new(self, :gearbox_limit, 'to be an Array of positives', gears) \
+            unless gears.is_a?(Array) && gears.all? { |num| num.positive? rescue false } # rubocop:disable Style/RescueModifier
 
-      @items = gearbox_items[@page - 1] || gearbox_items.last
+      @limit = gears[@page - 1] || gears.last
     end
 
-    # Setup @pages and @last based on the :gearbox_items variable (not used by Pagy::Countless)
-    def setup_pages_var
-      return super if !@vars[:gearbox_extra] || @vars[:items_extra]
+    # Asgnsi @offset based on the :gearbox_limit variable
+    def assign_offset
+      return super if !@vars[:gearbox_extra] || @vars[:limit_extra]
 
-      gearbox_items = @vars[:gearbox_items]
-      # This algorithm is thousands of times faster than the one in the geared_pagination gem
-      @pages = @last = (if @count > (sum = gearbox_items.sum)
-                          [((@count - sum).to_f / gearbox_items.last).ceil, 1].max + gearbox_items.count
-                        else
-                          pages     = 0
-                          remainder = @count
-                          while remainder.positive?
-                            pages     += 1
-                            remainder -= gearbox_items[pages - 1]
-                          end
-                          [pages, 1].max
-                        end)
+      gears   = @vars[:gearbox_limit]
+      @offset = if @page <= gears.count
+                  gears[0, @page - 1].sum
+                else
+                  gears.sum + (gears.last * (@page - gears.count - 1))
+                end + @outset
     end
 
-    # Setup @offset based on the :gearbox_items variable
-    def setup_offset_var
-      return super if !@vars[:gearbox_extra] || @vars[:items_extra]
+    # Assign @last based on the :gearbox_limit variable and @count
+    def assign_last
+      return super if !@vars[:gearbox_extra] || @vars[:limit_extra]
 
-      gearbox_items = @vars[:gearbox_items]
-      @offset       = if @page <= gearbox_items.count
-                        gearbox_items[0, @page - 1].sum
-                      else
-                        gearbox_items.sum + (gearbox_items.last * (@page - gearbox_items.count - 1))
-                      end + @outset
+      gears = @vars[:gearbox_limit]
+      # This algorithm is thousands of times faster than the one in the geared_pagination gem
+      @last = (if count > (sum = gears.sum)
+                 [((count - sum).to_f / gears.last).ceil, 1].max + gears.count
+               else
+                 pages     = 0
+                 remainder = count
+                 while remainder.positive?
+                   pages     += 1
+                   remainder -= gears[pages - 1]
+                 end
+                 [pages, 1].max
+               end)
+      @last = @vars[:max_pages] if @vars[:max_pages] && @last > @vars[:max_pages]
     end
   end
   prepend GearboxExtra

data/lib/pagy/extras/headers.rb

@@ -1,11 +1,11 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/headers
 # frozen_string_literal: true
 
-require 'pagy/url_helpers'
+require_relative '../url_helpers'
 
 class Pagy # :nodoc:
   DEFAULT[:headers] = { page:  'current-page',
-                        items: 'page-items',
+                        limit: 'page-items',
                         count: 'total-count',
                         pages: 'total-pages' }
   # Add specialized backend methods to add pagination response headers
@@ -21,32 +21,33 @@ class Pagy # :nodoc:
 
     # Generate a hash of RFC-8288 compliant http headers
     def pagy_headers(pagy)
-      pagy_headers_hash(pagy).tap do |hash|
-        hash['link'] = hash['link'].map { |rel, link| %(<#{link}>; rel="#{rel}") }.join(', ')
-      end
-    end
+      headers = pagy.vars[:headers]
+      { 'link' => link(pagy) }.tap do |hash|
+        hash[headers[:page]]  = pagy.page.to_s if pagy.page && headers[:page]
+        hash[headers[:limit]] = pagy.limit.to_s \
+            if headers[:limit] && !(defined?(Calendar) && pagy.is_a?(Calendar::Unit))
+        return hash if (defined?(Countless) && pagy.is_a?(Countless)) || \
+                       (defined?(Keyset) && pagy.is_a?(Keyset))
 
-    # Generates a hash structure of the headers
-    def pagy_headers_hash(pagy)
-      countless             = defined?(Countless) && pagy.is_a?(Countless)
-      rel                   = { 'first' => 1, 'prev' => pagy.prev, 'next' => pagy.next }
-      rel['last']           = pagy.last unless countless
-      url_str               = pagy_url_for(pagy, PAGE_TOKEN, absolute: true)
-      link                  = rel.filter_map do |r, num|
-                                next unless num # rubocop:disable Layout/EmptyLineAfterGuardClause
-                                [r, url_str.sub(PAGE_TOKEN, num.to_s)]
-                              end.compact.to_h
-      hash                  = { 'link' => link }
-      headers               = pagy.vars[:headers]
-      hash[headers[:page]]  = pagy.page.to_s if headers[:page]
-      if headers[:items] && !(defined?(Calendar) && pagy.is_a?(Calendar))  # items is not for Calendar
-        hash[headers[:items]] = pagy.vars[:items].to_s
-      end
-      unless countless
-        hash[headers[:pages]] = pagy.pages.to_s if headers[:pages]
+        hash[headers[:pages]] = pagy.last.to_s if headers[:pages]
         hash[headers[:count]] = pagy.count.to_s if pagy.count && headers[:count] # count may be nil with Calendar
       end
-      hash
+    end
+
+    def link(pagy)
+      [].tap do |link|
+        if defined?(Keyset) && pagy.is_a?(Keyset)
+          link << %(<#{pagy_url_for(pagy, nil, absolute: true)}>; rel="first")
+          link << %(<#{pagy_url_for(pagy, pagy.next, absolute: true)}>; rel="next") if pagy.next
+        else
+          url_str = pagy_url_for(pagy, PAGE_TOKEN, absolute: true)
+          link << %(<#{url_str.sub(PAGE_TOKEN, '1')}>; rel="first")
+          link << %(<#{url_str.sub(PAGE_TOKEN, pagy.prev.to_s)}>; rel="prev") if pagy.prev
+          link << %(<#{url_str.sub(PAGE_TOKEN, pagy.next.to_s)}>; rel="next") if pagy.next
+          link << %(<#{url_str.sub(PAGE_TOKEN, pagy.last.to_s)}>; rel="last") \
+              unless defined?(Countless) && pagy.is_a?(Countless)
+        end
+      end.join(', ')
     end
   end
   Backend.prepend HeadersExtra

data/lib/pagy/extras/i18n.rb

@@ -19,7 +19,7 @@ class Pagy # :nodoc:
       end
     end
   end
-  Calendar.prepend I18nExtra::CalendarOverride if defined?(Calendar)
+  Calendar::Unit.prepend I18nExtra::CalendarOverride if defined?(Calendar::Unit)
 
   # Add the pagy locales to the I18n.load_path
   ::I18n.load_path += Dir[Pagy.root.join('locales', '*.yml')]

data/lib/pagy/extras/js_tools.rb

@@ -1,20 +1,25 @@
 # frozen_string_literal: true
 
+require_relative '../b64'
+
 class Pagy # :nodoc:
   DEFAULT[:steps] = false # default false will use {0 => @vars[:size]}
 
   # Private module documented in the main classes
   module JSTools
+    # Dummy tag for input helpers: needed because Turbo does not intercept window.location changes
+    A_TAG = '<a href="#" style="display: none;">#</a>'
+
     # Additions for the Pagy class
     module PagyAddOn
       # `Pagy` instance method used by the `pagy*_nav_js` helpers.
       # It returns the sequels of width/series generated from the :steps hash
       # Example:
-      # >> pagy = Pagy.new(count:1000, page: 20, steps: {0 => [1,2,2,1], 350 => [2,3,3,2], 550 => [3,4,4,3]})
+      # >> pagy = Pagy.new(count:1000, page: 20, steps: {0 => 5, 350 => 7, 550 => 9})
       # >> pagy.sequels
-      # #=> { "0"   => [1, :gap, 18, 19, "20", 21, 22, :gap, 50],
-      #       "350" => [1, 2, :gap, 17, 18, 19, "20", 21, 22, 23, :gap, 49, 50],
-      #       "550" => [1, 2, 3, :gap, 16, 17, 18, 19, "20", 21, 22, 23, 24, :gap, 48, 49, 50] }
+      # #=> { "0"   => [18, 19, "20", 21, 22],
+      #       "350" => [1, :gap, 19, "20", 21, :gap, 50],
+      #       "550" => [1 :gap, 18, 19, "20", 21, 22, :gap, 50] }
       # Notice: if :steps is false it will use the single {0 => @vars[:size]} size
       def sequels(steps: @vars[:steps] || { 0 => @vars[:size] }, **_)
         raise VariableError.new(self, :steps, 'to define the 0 width', steps) unless steps.key?(0)
@@ -39,7 +44,7 @@ class Pagy # :nodoc:
         end
       end
     end
-    Calendar.prepend CalendarOverride if defined?(Calendar)
+    Calendar::Unit.prepend CalendarOverride if defined?(Calendar::Unit)
 
     # Additions for the Frontend
     module FrontendAddOn
@@ -48,8 +53,7 @@ class Pagy # :nodoc:
         # Base64 encoded JSON is smaller than HTML escaped JSON
         def pagy_data(pagy, *args)
           args << pagy.vars[:page_param] if pagy.vars[:trim_extra]
-          strict_base64_encoded = [Oj.dump(args, mode: :strict)].pack('m0')
-          %(data-pagy="#{strict_base64_encoded}")
+          %(data-pagy="#{B64.encode(Oj.dump(args, mode: :strict))}")
         end
       else
         require 'json'
@@ -57,8 +61,7 @@ class Pagy # :nodoc:
         # Base64 encoded JSON is smaller than HTML escaped JSON
         def pagy_data(pagy, *args)
           args << pagy.vars[:page_param] if pagy.vars[:trim_extra]
-          strict_base64_encoded = [args.to_json].pack('m0')
-          %(data-pagy="#{strict_base64_encoded}")
+          %(data-pagy="#{B64.encode(args.to_json)}")
         end
       end
     end

data/lib/pagy/extras/jsonapi.rb

@@ -1,7 +1,7 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/jsonapi
 # frozen_string_literal: true
 
-require 'pagy/url_helpers'
+require_relative '../url_helpers'
 
 class Pagy # :nodoc:
   DEFAULT[:jsonapi] = true
@@ -24,10 +24,17 @@ class Pagy # :nodoc:
 
       # Return the jsonapi links
       def pagy_jsonapi_links(pagy, **opts)
-        { first: pagy_url_for(pagy, 1,         **opts),
-          last:  pagy_url_for(pagy, pagy.last, **opts),
-          prev:  pagy.prev ? pagy_url_for(pagy, pagy.prev, **opts) : nil,
-          next:  pagy.next ? pagy_url_for(pagy, pagy.next, **opts) : nil }
+        if defined?(Pagy::Keyset) && pagy.is_a?(Pagy::Keyset)
+          { first: pagy_url_for(pagy, nil, **opts),
+            last: nil,
+            prev: nil,
+            next:  pagy.next ? pagy_url_for(pagy, pagy.next, **opts) : nil }
+        else
+          { first: pagy_url_for(pagy, 1, **opts),
+            last:  pagy_url_for(pagy, pagy.last, **opts),
+            prev:  pagy.prev ? pagy_url_for(pagy, pagy.prev, **opts) : nil,
+            next:  pagy.next ? pagy_url_for(pagy, pagy.next, **opts) : nil }
+        end
       end
 
       # Should skip the jsonapi
@@ -40,38 +47,41 @@ class Pagy # :nodoc:
       # Override the Backend method
       def pagy_get_page(vars)
         return super if pagy_skip_jsonapi?(vars)
-        return 1 if params[:page].nil?
+        return if params[:page].nil?
 
-        params[:page][vars[:page_param] || DEFAULT[:page_param]].to_i
+        params[:page][vars[:page_param] || DEFAULT[:page_param]]
       end
     end
     Backend.prepend BackendOverride
 
-    # Module overriding ItemsExtra
-    module ItemsExtraOverride
+    # Module overriding LimitExtra
+    module LimitExtraOverride
       private
 
-      # Override the ItemsExtra::Backend method
-      def pagy_get_items_size(vars)
+      # Override the LimitExtra::Backend method
+      def pagy_get_limit_param(vars)
         return super if pagy_skip_jsonapi?(vars)
         return if params[:page].nil?
 
-        params[:page][vars[:items_param] || DEFAULT[:items_param]]
+        params[:page][vars[:limit_param] || DEFAULT[:limit_param]]
       end
     end
     # :nocov:
-    ItemsExtra::BackendAddOn.prepend ItemsExtraOverride if defined?(ItemsExtra::BackendAddOn)
+    LimitExtra::BackendAddOn.prepend LimitExtraOverride if defined?(LimitExtra::BackendAddOn)
     # :nocov:
 
     # Module overriding UrlHelper
     module UrlHelperOverride
       # Override UrlHelper method
-      def pagy_set_query_params(page, vars, params)
+      def pagy_set_query_params(page, vars, query_params)
         return super unless vars[:jsonapi]
 
-        params['page'] ||= {}
-        params['page'][vars[:page_param].to_s]  = page
-        params['page'][vars[:items_param].to_s] = vars[:items] if vars[:items_extra]
+        query_params['page'] ||= {}
+        query_params['page'][vars[:page_param].to_s]  = page if page
+        query_params['page'][vars[:limit_param].to_s] = vars[:limit] if vars[:limit_extra]
+        # :nocov:
+        query_params.delete(:page) if query_params['page'].empty?
+        # :nocov:
       end
     end
     UrlHelpers.prepend UrlHelperOverride

data/lib/pagy/extras/keyset.rb

@@ -0,0 +1,26 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/keyset
+# frozen_string_literal: true
+
+require_relative '../keyset'
+
+class Pagy # :nodoc:
+  # Add keyset pagination
+  module KeysetExtra
+    private
+
+    # Return Pagy::Keyset object and paginated records
+    def pagy_keyset(set, **vars)
+      pagy = Keyset.new(set, **pagy_keyset_get_vars(vars))
+      [pagy, pagy.records]
+    end
+
+    # Sub-method called only by #pagy_keyset: here for easy customization of variables by overriding
+    def pagy_keyset_get_vars(vars)
+      vars.tap do |v|
+        v[:page]  ||= pagy_get_page(v)
+        v[:limit] ||= pagy_get_limit(v)
+      end
+    end
+  end
+  Backend.prepend KeysetExtra
+end

data/lib/pagy/extras/limit.rb

@@ -0,0 +1,63 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/limit
+# frozen_string_literal: true
+
+require_relative 'js_tools'
+
+class Pagy # :nodoc:
+  DEFAULT[:limit_param] = :limit
+  DEFAULT[:limit_max]   = 100
+  DEFAULT[:limit_extra] = true   # extra enabled by default
+
+  # Allow the client to request a custom limit per page with an optional selector UI
+  module LimitExtra
+    # Additions for the Backend module
+    module BackendAddOn
+      private
+
+      # Set the limit variable considering the params and other pagy variables
+      def pagy_get_limit(vars)
+        return unless vars.key?(:limit_extra) ? vars[:limit_extra] : DEFAULT[:limit_extra] # :limit_extra is false
+        return unless (limit_count = pagy_get_limit_param(vars))                            # no limit from request params
+
+        vars[:limit] = [limit_count.to_i, vars.key?(:limit_max) ? vars[:limit_max] : DEFAULT[:limit_max]].compact.min
+      end
+
+      # Get the limit count from the params
+      # Overridable by the jsonapi extra
+      def pagy_get_limit_param(vars)
+        params[vars[:limit_param] || DEFAULT[:limit_param]]
+      end
+    end
+    Backend.prepend LimitExtra::BackendAddOn
+
+    # Additions for the Frontend module
+    module FrontendAddOn
+      LIMIT_TOKEN = '__pagy_limit__'
+
+      # Return the limit selector HTML. For example "Show [20] items per page"
+      def pagy_limit_selector_js(pagy, id: nil, item_name: nil)
+        return '' unless pagy.vars[:limit_extra]
+
+        id           = %( id="#{id}") if id
+        vars         = pagy.vars
+        limit        = vars[:limit]
+        vars[:limit] = LIMIT_TOKEN
+        url_token    = pagy_url_for(pagy, PAGE_TOKEN)
+        vars[:limit] = limit # restore the limit
+
+        limit_input = %(<input name="limit" type="number" min="1" max="#{vars[:limit_max]}" value="#{
+                          limit}" style="padding: 0; text-align: center; width: #{limit.to_s.length + 1}rem;">#{JSTools::A_TAG})
+
+        %(<span#{id} class="pagy limit-selector-js" #{
+            pagy_data(pagy, :selector, pagy.from, url_token)
+          }><label>#{
+            pagy_t('pagy.limit_selector_js',
+                   item_name: item_name || pagy_t('pagy.item_name', count: limit),
+                   limit_input:,
+                   count: limit)
+          }</label></span>)
+      end
+    end
+    Frontend.prepend LimitExtra::FrontendAddOn
+  end
+end

data/lib/pagy/extras/meilisearch.rb

@@ -20,12 +20,12 @@ class Pagy # :nodoc:
     # Extension for the Pagy class
     module PagyExtension
       # Create a Pagy object from a Meilisearch results
-      def new_from_meilisearch(results, vars = {})
-        vars[:items] = results.raw_answer['hitsPerPage']
+      def new_from_meilisearch(results, **vars)
+        vars[:limit] = results.raw_answer['hitsPerPage']
         vars[:page]  = results.raw_answer['page']
         vars[:count] = results.raw_answer['totalHits']
 
-        new(vars)
+        new(**vars)
       end
     end
     Pagy.extend PagyExtension
@@ -35,17 +35,17 @@ class Pagy # :nodoc:
       private
 
       # Return Pagy object and results
-      def pagy_meilisearch(pagy_search_args, vars = {})
+      def pagy_meilisearch(pagy_search_args, **vars)
         model, term, options    = pagy_search_args
         vars                    = pagy_meilisearch_get_vars(nil, vars)
-        options[:hits_per_page] = vars[:items]
+        options[:hits_per_page] = vars[:limit]
         options[:page]          = vars[:page]
         results                 = model.send(:ms_search, term, options)
         vars[:count]            = results.raw_answer['totalHits']
 
-        pagy                    = ::Pagy.new(vars)
+        pagy                    = ::Pagy.new(**vars)
         # with :last_page overflow we need to re-run the method in order to get the hits
-        return pagy_meilisearch(pagy_search_args, vars.merge(page: pagy.page)) \
+        return pagy_meilisearch(pagy_search_args, **vars, page: pagy.page) \
                if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
 
         [pagy, results]
@@ -54,10 +54,10 @@ class Pagy # :nodoc:
       # Sub-method called only by #pagy_meilisearch: here for easy customization of variables by overriding.
       # The _collection argument is not available when the method is called.
       def pagy_meilisearch_get_vars(_collection, vars)
-        pagy_set_items_from_params(vars) if defined?(ItemsExtra)
-        vars[:items] ||= DEFAULT[:items]
-        vars[:page]  ||= pagy_get_page(vars)
-        vars
+        vars.tap do |v|
+          v[:page]  ||= pagy_get_page(v)
+          v[:limit] ||= pagy_get_limit(v) || DEFAULT[:limit]
+        end
       end
     end
     Backend.prepend BackendAddOn

data/lib/pagy/extras/metadata.rb

@@ -1,11 +1,11 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/metadata
 # frozen_string_literal: true
 
-require 'pagy/url_helpers'
+require_relative '../url_helpers'
 
 class Pagy # :nodoc:
   DEFAULT[:metadata] = %i[ scaffold_url first_url prev_url page_url next_url last_url
-                           count page items vars pages last in from to prev next series ]
+                           count page limit vars pages last in from to prev next series ]
 
   # Add a specialized backend method for pagination metadata
   module MetadataExtra
@@ -17,7 +17,11 @@ class Pagy # :nodoc:
     def pagy_metadata(pagy, absolute: nil)
       scaffold_url = pagy_url_for(pagy, PAGE_TOKEN, absolute:)
       {}.tap do |metadata|
-        keys = defined?(Calendar) && pagy.is_a?(Calendar) ? pagy.vars[:metadata] - %i[count items] : pagy.vars[:metadata]
+        keys = if defined?(Calendar::Unit) && pagy.is_a?(Calendar::Unit)
+                 pagy.vars[:metadata] - %i[count limit]
+               else
+                 pagy.vars[:metadata]
+               end
         keys.each do |key|
           metadata[key] = case key
                           when :scaffold_url then scaffold_url

data/lib/pagy/extras/overflow.rb

@@ -14,7 +14,7 @@ class Pagy # :nodoc:
       end
 
       # Add rescue clause for different behaviors
-      def initialize(vars)
+      def initialize(**vars)
         @overflow ||= false                            # still true if :last_page re-run the method after an overflow
         super
       rescue OverflowError
@@ -24,11 +24,12 @@ class Pagy # :nodoc:
           raise                                        # same as without the extra
         when :last_page
           requested_page = @vars[:page]                # save the requested page (even after re-run)
-          initialize vars.merge!(page: @last)          # re-run with the last page
+          initialize(**vars, page: @last)              # re-run with the last page
           @vars[:page] = requested_page                # restore the requested page
         when :empty_page
-          @offset = @items = @from = @to = 0           # vars relative to the actual page
-          if defined?(Calendar) && is_a?(Calendar)     # only for Calendar instances
+          @offset = @limit = @in = @from = @to = 0     # vars relative to the actual page
+          if defined?(Calendar::Unit) \
+              && is_a?(Calendar::Unit)                 # only for Calendar::Units instances
             edge = @order == :asc ? @final : @initial  # get the edge of the overflow side (neat, but any time would do)
             @from = @to = edge                         # set both to the edge utc time (a >=&&< query will get no records)
           end
@@ -51,12 +52,12 @@ class Pagy # :nodoc:
       end
     end
     Pagy.prepend PagyOverride
-    Pagy::Calendar.prepend PagyOverride if defined?(Calendar)
+    Pagy::Calendar::Unit.prepend PagyOverride if defined?(Calendar::Unit)
 
     # Support for Pagy::Countless class
     module CountlessOverride
       # Add rescue clause for different behaviors
-      def finalize(items)
+      def finalize(fetched_size)
         @overflow = false
         super
       rescue OverflowError
@@ -65,8 +66,8 @@ class Pagy # :nodoc:
         when :exception
           raise                                        # same as without the extra
         when :empty_page
-          @offset = @items = @from = @to = 0           # vars relative to the actual page
-          @vars[:size] = []                            # no page in the series
+          @offset = @limit = @from = @to = 0           # vars relative to the actual page
+          @vars[:size] = 0                             # no page in the series
           self
         else
           raise VariableError.new(self, :overflow, 'to be in [:empty_page, :exception]', @vars[:overflow])

data/lib/pagy/extras/pagy.rb

@@ -1,7 +1,7 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/pagy
 # frozen_string_literal: true
 
-require 'pagy/extras/js_tools'
+require_relative 'js_tools'
 
 class Pagy # :nodoc:
   # Frontend modules are specially optimized for performance.
@@ -12,7 +12,7 @@ class Pagy # :nodoc:
     def pagy_nav_js(pagy, id: nil, aria_label: nil, **vars)
       sequels = pagy.sequels(**vars)
       id      = %( id="#{id}") if id
-      a       = pagy_anchor(pagy)
+      a       = pagy_anchor(pagy, **vars)
       tokens  = { 'before'  => prev_a(pagy, a),
                   'a'       => a.(PAGE_TOKEN, LABEL_TOKEN),
                   'current' => %(<a class="current" role="link" aria-current="page" aria-disabled="true">#{
@@ -27,17 +27,17 @@ class Pagy # :nodoc:
     end
 
     # Javascript combo pagination: it returns a nav with a data-pagy attribute used by the pagy.js file
-    def pagy_combo_nav_js(pagy, id: nil, aria_label: nil)
+    def pagy_combo_nav_js(pagy, id: nil, aria_label: nil, **vars)
       id    = %( id="#{id}") if id
-      a     = pagy_anchor(pagy)
+      a     = pagy_anchor(pagy, **vars)
       pages = pagy.pages
 
       page_input = %(<input name="page" type="number" min="1" max="#{pages}" value="#{pagy.page}" aria-current="page" ) <<
-                   %(style="text-align: center; width: #{pages.to_s.length + 1}rem; padding: 0;">)
+                   %(style="text-align: center; width: #{pages.to_s.length + 1}rem; padding: 0;">#{JSTools::A_TAG})
 
       %(<nav#{id} class="pagy combo-nav-js" #{
           nav_aria_label(pagy, aria_label:)} #{
-          pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN))}>#{
+          pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN, **vars))}>#{
           prev_a(pagy, a)
         }<label>#{
           pagy_t('pagy.combo_nav_js', page_input:, pages:)
@@ -47,35 +47,35 @@ class Pagy # :nodoc:
     end
 
     # Return the previous page URL string or nil
-    def pagy_prev_url(pagy, absolute: false)
-      pagy_url_for(pagy, pagy.prev, absolute:) if pagy.prev
+    def pagy_prev_url(pagy, **vars)
+      pagy_url_for(pagy, pagy.prev, **vars) if pagy.prev
     end
 
     # Return the next page URL string or nil
-    def pagy_next_url(pagy, absolute: false)
-      pagy_url_for(pagy, pagy.next, absolute:) if pagy.next
+    def pagy_next_url(pagy, **vars)
+      pagy_url_for(pagy, pagy.next, **vars) if pagy.next
     end
 
     # Return the enabled/disabled previous page anchor tag
-    def pagy_prev_a(pagy, text: pagy_t('pagy.prev'), aria_label: pagy_t('pagy.aria_label.prev'))
-      a = pagy_anchor(pagy)
+    def pagy_prev_a(pagy, text: pagy_t('pagy.prev'), aria_label: pagy_t('pagy.aria_label.prev'), **vars)
+      a = pagy_anchor(pagy, **vars)
       prev_a(pagy, a, text:, aria_label:)
     end
 
     # Return the enabled/disabled next page anchor tag
-    def pagy_next_a(pagy, text: pagy_t('pagy.next'), aria_label: pagy_t('pagy.aria_label.prev'))
-      a = pagy_anchor(pagy)
+    def pagy_next_a(pagy, text: pagy_t('pagy.next'), aria_label: pagy_t('pagy.aria_label.next'), **vars)
+      a = pagy_anchor(pagy, **vars)
       next_a(pagy, a, text:, aria_label:)
     end
 
     # Conditionally return the previous page link tag
-    def pagy_prev_link(pagy, absolute: false)
-      %(<link href="#{pagy_url_for(pagy, pagy.prev, absolute:)}"/>) if pagy.prev
+    def pagy_prev_link(pagy, **vars)
+      %(<link href="#{pagy_url_for(pagy, pagy.prev, **vars)}"/>) if pagy.prev
     end
 
     # Conditionally return the next page link tag
-    def pagy_next_link(pagy, absolute: false)
-      %(<link href="#{pagy_url_for(pagy, pagy.next, absolute:)}"/>) if pagy.next
+    def pagy_next_link(pagy, **vars)
+      %(<link href="#{pagy_url_for(pagy, pagy.next, **vars)}"/>) if pagy.next
     end
   end
   Frontend.prepend PagyExtra