pagy 9.4.0 → 43.0.0.rc1

data/lib/pagy/extras/keyset.rb

@@ -1,30 +0,0 @@
-# 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)
-      vars[:page]  ||= pagy_get_page(vars, force_integer: false) # allow nil
-      vars[:limit] ||= pagy_get_limit(vars)
-      pagy = Keyset.new(set, **vars)
-      [pagy, pagy.records]
-    end
-
-    # Return the URL string for the first page
-    def pagy_keyset_first_url(pagy, **vars)
-      pagy_url_for(pagy, nil, **vars)
-    end
-
-    # Return the URL string for the next page or nil
-    def pagy_keyset_next_url(pagy, **vars)
-      pagy_url_for(pagy, pagy.next, **vars) if pagy.next
-    end
-  end
-  Backend.prepend KeysetExtra
-end

data/lib/pagy/extras/limit.rb

@@ -1,63 +0,0 @@
-# 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 super unless vars.key?(:limit_extra) ? vars[:limit_extra] : DEFAULT[:limit_extra] # :limit_extra is false
-        return super 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

@@ -1,57 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/meilisearch
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  DEFAULT[:meilisearch_search]      ||= :ms_search
-  DEFAULT[:meilisearch_pagy_search] ||= :pagy_search
-
-  # Paginate Meilisearch results
-  module MeilisearchExtra
-    module ModelExtension # :nodoc:
-      # Return an array used to delay the call of #search
-      # after the pagination variables are merged to the options
-      def pagy_meilisearch(query, params = {})
-        [self, query, params]
-      end
-      alias_method DEFAULT[:meilisearch_pagy_search], :pagy_meilisearch
-    end
-    Pagy::Meilisearch = ModelExtension
-
-    # Extension for the Pagy class
-    module PagyExtension
-      # Create a Pagy object from a Meilisearch results
-      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)
-      end
-    end
-    Pagy.extend PagyExtension
-
-    # Add specialized backend methods to paginate Meilisearch results
-    module BackendAddOn
-      private
-
-      # Return Pagy object and results
-      def pagy_meilisearch(pagy_search_args, **vars)
-        vars[:page]  ||= pagy_get_page(vars)
-        vars[:limit] ||= pagy_get_limit(vars)
-        model, term, options    = pagy_search_args
-        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)
-        # with :last_page overflow we need to re-run the method in order to get the hits
-        return pagy_meilisearch(pagy_search_args, **vars, page: pagy.page) \
-               if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
-
-        [pagy, results]
-      end
-    end
-    Backend.prepend BackendAddOn
-  end
-end

data/lib/pagy/extras/metadata.rb

@@ -1,42 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/metadata
-# frozen_string_literal: true
-
-require_relative '../url_helpers'
-
-class Pagy # :nodoc:
-  DEFAULT[:metadata] = %i[ scaffold_url first_url prev_url page_url next_url last_url
-                           count page limit vars pages last in from to prev next series ]
-
-  # Add a specialized backend method for pagination metadata
-  module MetadataExtra
-    private
-
-    include UrlHelpers
-
-    # Return the metadata hash
-    def pagy_metadata(pagy, absolute: nil)
-      scaffold_url = pagy_url_for(pagy, PAGE_TOKEN, absolute:)
-      {}.tap do |metadata|
-        keys = if defined?(::Pagy::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
-                          when :first_url    then scaffold_url.sub(PAGE_TOKEN, 1.to_s)
-                          when :prev_url     then scaffold_url.sub(PAGE_TOKEN, pagy.prev.to_s)
-                          when :page_url     then scaffold_url.sub(PAGE_TOKEN, pagy.page.to_s)
-                          when :next_url     then scaffold_url.sub(PAGE_TOKEN, pagy.next.to_s)
-                          when :last_url     then scaffold_url.sub(PAGE_TOKEN, pagy.last.to_s)
-                          else pagy.send(key)
-                          end
-        rescue NoMethodError
-          raise VariableError.new(pagy, :metadata, 'to contain known keys', key)
-        end
-      end
-    end
-  end
-  Backend.prepend MetadataExtra
-end

data/lib/pagy/extras/overflow.rb

@@ -1,81 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/overflow
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  DEFAULT[:overflow] = :empty_page
-
-  # Handles OverflowError exceptions for different classes with different options
-  module OverflowExtra
-    # Support for Pagy class
-    module PagyOverride
-      # Is the requested page overflowing?
-      def overflow?
-        @overflow
-      end
-
-      # Add rescue clause for different behaviors
-      def initialize(**vars)
-        @overflow ||= false                            # still true if :last_page re-run the method after an overflow
-        super
-      rescue OverflowError
-        @overflow = true                               # add the overflow flag
-        case @vars[:overflow]
-        when :exception
-          raise                                        # same as without the extra
-        when :last_page
-          requested_page = @vars[:page]                # save the requested page (even after re-run)
-          initialize(**vars, page: @last)              # re-run with the last page
-          @vars[:page] = requested_page                # restore the requested page
-        when :empty_page
-          @in = @from = @to = 0                        # vars relative to the actual page
-          if defined?(::Pagy::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 time (a >=&&< query will get no records)
-          end
-          @prev = @last                                # prev relative to the actual page
-          extend Series                                # special series for :empty_page
-        else
-          raise VariableError.new(self, :overflow, 'to be in [:last_page, :empty_page, :exception]', @vars[:overflow])
-        end
-      end
-
-      # Special series for empty page
-      module Series
-        def series(*, **)
-          @page = @last                                # series for last page
-          super.tap do |s|                             # call original series
-            s[s.index(@page.to_s)] = @page             # string to integer (i.e. no current page)
-            @page = @vars[:page]                       # restore the actual page
-          end
-        end
-      end
-    end
-    Pagy.prepend PagyOverride
-    Pagy::Calendar::Unit.prepend PagyOverride if defined?(::Pagy::Calendar::Unit)
-
-    # Support for Pagy::Countless class
-    module CountlessOverride
-      # Add rescue clause for different behaviors
-      def finalize(fetched_size)
-        @overflow = false
-        super
-      rescue OverflowError
-        @overflow = true                               # add the overflow flag
-        case @vars[:overflow]
-        when :exception
-          raise                                        # same as without the extra
-        when :empty_page
-          @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])
-        end
-      end
-    end
-    # :nocov:
-    Pagy::Countless.prepend CountlessOverride if defined?(::Pagy::Countless)
-    # :nocov:
-  end
-end

data/lib/pagy/extras/pagy.rb

@@ -1,82 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/pagy
-# frozen_string_literal: true
-
-require_relative 'js_tools'
-
-class Pagy # :nodoc:
-  # Frontend modules are specially optimized for performance.
-  # The resulting code may not look very elegant, but produces the best benchmarks
-  module PagyExtra
-    # pagy_nav is defined in the Frontend itself
-    # Javascript pagination: it returns a nav with a data-pagy attribute used by the pagy.js file
-    def pagy_nav_js(pagy, id: nil, aria_label: nil, **vars)
-      sequels = pagy.sequels(**vars)
-      id      = %( id="#{id}") if id
-      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">#{
-                                   LABEL_TOKEN}</a>),
-                  'gap'     => %(<a class="gap" role="link" aria-disabled="true">#{pagy_t('pagy.gap')}</a>),
-                  'after'   => next_a(pagy, a) }
-
-      %(<nav#{id} class="#{'pagy-rjs ' if sequels.size > 1}pagy nav-js" #{
-          nav_aria_label(pagy, aria_label:)} #{
-          pagy_data(pagy, :nav, tokens, sequels, pagy.label_sequels(sequels))
-        }></nav>)
-    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, **vars)
-      id    = %( id="#{id}") if id
-      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;">#{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, **vars))}>#{
-          prev_a(pagy, a)
-        }<label>#{
-          pagy_t('pagy.combo_nav_js', page_input:, pages:)
-        }</label>#{
-          next_a(pagy, a)
-        }</nav>)
-    end
-
-    # Return the previous page URL string or nil
-    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, **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'), **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.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, **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, **vars)
-      %(<link href="#{pagy_url_for(pagy, pagy.next, **vars)}"/>) if pagy.next
-    end
-  end
-  Frontend.prepend PagyExtra
-end

data/lib/pagy/extras/searchkick.rb

@@ -1,59 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/searchkick
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  DEFAULT[:searchkick_search]      ||= :search
-  DEFAULT[:searchkick_pagy_search] ||= :pagy_search
-
-  # Paginate Searchkick::Results objects
-  module SearchkickExtra
-    module ModelExtension # :nodoc:
-      # Return an array used to delay the call of #search
-      # after the pagination variables are merged to the options.
-      # It also pushes to the same array an optional method call.
-      def pagy_searchkick(term = '*', **options, &block)
-        [self, term, options, block].tap do |args|
-          args.define_singleton_method(:method_missing) { |*a| args += a }
-        end
-      end
-      alias_method Pagy::DEFAULT[:searchkick_pagy_search], :pagy_searchkick
-    end
-    Pagy::Searchkick = ModelExtension
-
-    # Additions for the Pagy class
-    module PagyExtension
-      # Create a Pagy object from a Searchkick::Results object
-      def new_from_searchkick(results, **vars)
-        vars[:limit] = results.options[:per_page]
-        vars[:page]  = results.options[:page]
-        vars[:count] = results.total_count
-        new(**vars)
-      end
-    end
-    Pagy.extend PagyExtension
-
-    # Add specialized backend methods to paginate Searchkick::Results
-    module BackendAddOn
-      private
-
-      # Return Pagy object and results
-      def pagy_searchkick(pagy_search_args, **vars)
-        vars[:page]  ||= pagy_get_page(vars)
-        vars[:limit] ||= pagy_get_limit(vars)
-        model, term, options, block, *called = pagy_search_args
-        options[:per_page] = vars[:limit]
-        options[:page]     = vars[:page]
-        results            = model.send(DEFAULT[:searchkick_search], term, **options, &block)
-        vars[:count]       = results.total_count
-
-        pagy = ::Pagy.new(**vars)
-        # with :last_page overflow we need to re-run the method in order to get the hits
-        return pagy_searchkick(pagy_search_args, **vars, page: pagy.page) \
-               if defined?(::Pagy::OverflowExtra) && pagy.overflow? && pagy.vars[:overflow] == :last_page
-
-        [pagy, called.empty? ? results : results.send(*called)]
-      end
-    end
-    Backend.prepend BackendAddOn
-  end
-end

data/lib/pagy/extras/size.rb

@@ -1,40 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/size
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  # Implement the legacy bar using the array size.
-  # Unless you have very specific requirements, use the faster and better looking default bar.
-  module SizeExtra
-    # Implements the old series algorithm
-    def series(size: @vars[:size], **_)
-      return super unless size.is_a?(Array)
-      return [] if size == []
-      raise VariableError.new(self, :size, 'to be an Array of 4 Integers or []', size) \
-            unless size.is_a?(Array) && size.size == 4 && size.all? { |num| !num.negative? rescue false } # rubocop:disable Style/RescueModifier
-
-      [].tap do |series|
-        # This algorithm is up to ~5x faster and ~2.3x lighter than the previous one (pagy < 4.3)
-        # However the behavior of the legacy nav bar was taken straight from WillPaginate and Kaminari:
-        # it's ill-concieved and complicates the experience of devs and users.
-        left_gap_start  = 1 + size[0]
-        left_gap_end    = @page - size[1] - 1
-        right_gap_start = @page + size[2] + 1
-        right_gap_end   = @last - size[3]
-        left_gap_end    = right_gap_end  if left_gap_end   > right_gap_end
-        right_gap_start = left_gap_start if left_gap_start > right_gap_start
-        start           = 1
-        if (left_gap_end - left_gap_start).positive?
-          series.push(*start...left_gap_start, :gap)
-          start = left_gap_end + 1
-        end
-        if (right_gap_end - right_gap_start).positive?
-          series.push(*start...right_gap_start, :gap)
-          start = right_gap_end + 1
-        end
-        series.push(*start..@last)
-        series[series.index(@page)] = @page.to_s
-      end
-    end
-  end
-  prepend SizeExtra
-end

data/lib/pagy/extras/standalone.rb

@@ -1,60 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/standalone
-# frozen_string_literal: true
-
-require 'uri'
-
-class Pagy # :nodoc:
-  # Use pagy without any request object, nor Rack environment/gem, nor any defined params method,
-  # even in the irb/rails console without any app or config.
-  module StandaloneExtra
-    # Extracted from Rack::Utils and reformatted for rubocop
-    # :nocov:
-    module QueryUtils
-      module_function
-
-      def build_nested_query(value, prefix = nil)
-        case value
-        when Array
-          value.map { |v| build_nested_query(v, "#{prefix}[]") }.join('&')
-        when Hash
-          value.map do |k, v|
-            build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-          end.delete_if(&:empty?).join('&')
-        when nil
-          escape(prefix)
-        else
-          raise ArgumentError, 'value must be a Hash' if prefix.nil?
-
-          "#{escape(prefix)}=#{escape(value)}"
-        end
-      end
-
-      def escape(str)
-        URI.encode_www_form_component(str)
-      end
-    end
-    # :nocov:
-
-    # Return the URL for the page. If there is no pagy.vars[:url]
-    # it works exactly as the regular #pagy_url_for, relying on the params method and Rack.
-    # If there is a defined pagy.vars[:url] variable it does not need the params method nor Rack.
-    def pagy_url_for(pagy, page, fragment: nil, **_)
-      return super unless pagy.vars[:url]
-
-      vars         = pagy.vars
-      params       = vars[:params].is_a?(Hash) ? vars[:params].clone : {}  # safe when it gets reused
-      pagy_set_query_params(page, vars, params)
-      params       = vars[:params].(params) if vars[:params].is_a?(Proc)
-      query_string = "?#{QueryUtils.build_nested_query(params)}"
-      "#{vars[:url]}#{query_string}#{fragment}"
-    end
-  end
-  UrlHelpers.prepend StandaloneExtra
-
-  # Define a dummy params method if it's not already defined in the including module
-  module Backend
-    def self.included(controller)
-      controller.define_method(:params) { {} } unless controller.method_defined?(:params)
-    end
-  end
-end

data/lib/pagy/extras/trim.rb

@@ -1,29 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/trim
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  DEFAULT[:trim_extra] = true   # extra enabled by default
-
-  # Remove the page=1 param from the first page link
-  module TrimExtra
-    # Override the original pagy_anchor.
-    # Call the pagy_trim method for page 1 if the trim_extra is enabled
-    def pagy_anchor(pagy, **_)
-      a_proc = super
-      return a_proc unless pagy.vars[:trim_extra]
-
-      lambda do |page, text = pagy.label_for(page), **opts|
-        a = +a_proc.(page, text, **opts)
-        return a unless page.to_s == '1'
-
-        pagy_trim(pagy, a) # in method for isolated testing
-      end
-    end
-
-    # Remove the :page_param param from the first page anchor
-    def pagy_trim(pagy, a)
-      a.sub!(/[?&]#{pagy.vars[:page_param]}=1\b(?!&)|\b#{pagy.vars[:page_param]}=1&/, '')
-    end
-  end
-  Frontend.prepend TrimExtra
-end

data/lib/pagy/frontend.rb

@@ -1,99 +0,0 @@
-# See Pagy::Frontend API documentation: https://ddnexus.github.io/pagy/docs/api/frontend
-# frozen_string_literal: true
-
-require_relative 'i18n'
-require_relative 'url_helpers'
-
-class Pagy
-  # Used for search and replace, hardcoded also in the pagy.js file
-  PAGE_TOKEN  = '__pagy_page__'
-  LABEL_TOKEN = '__pagy_label__'
-
-  # Frontend modules are specially optimized for performance.
-  # The resulting code may not look very elegant, but produces the best benchmarks
-  module Frontend
-    include UrlHelpers
-
-    # Return a performance optimized lambda to generate the HTML anchor element (a tag)
-    # Benchmarked on a 20 link nav: it is ~22x faster and uses ~18x less memory than rails' link_to
-    def pagy_anchor(pagy, anchor_string: nil, **vars)
-      anchor_string &&= %( #{anchor_string})
-      left, right = %(<a#{anchor_string} href="#{pagy_url_for(pagy, PAGE_TOKEN, **vars)}").split(PAGE_TOKEN, 2)
-      # lambda used by all the helpers
-      lambda do |page, text = pagy.label_for(page), classes: nil, aria_label: nil|
-        classes    = %( class="#{classes}") if classes
-        aria_label = %( aria-label="#{aria_label}") if aria_label
-        %(#{left}#{page}#{right}#{classes}#{aria_label}>#{text}</a>)
-      end
-    end
-
-    # Return examples: "Displaying items 41-60 of 324 in total" or "Displaying Products 41-60 of 324 in total"
-    def pagy_info(pagy, id: nil, item_name: nil)
-      id      = %( id="#{id}") if id
-      p_count = pagy.count
-      key     = if p_count.zero?
-                  'pagy.info.no_items'
-                elsif pagy.pages == 1
-                  'pagy.info.single_page'
-                else
-                  'pagy.info.multiple_pages'
-                end
-
-      %(<span#{id} class="pagy info">#{
-          pagy_t key, item_name: item_name || pagy_t('pagy.item_name', count: p_count),
-                      count: p_count, from: pagy.from, to: pagy.to
-        }</span>)
-    end
-
-    # Generic pagination: it returns the html with the series of links to the pages
-    def pagy_nav(pagy, id: nil, aria_label: nil, **vars)
-      id = %( id="#{id}") if id
-      a  = pagy_anchor(pagy, **vars)
-
-      html = %(<nav#{id} class="pagy nav" #{nav_aria_label(pagy, aria_label:)}>#{
-                 prev_a(pagy, a)})
-      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << case item
-                when Integer
-                  a.(item)
-                when String
-                  %(<a role="link" aria-disabled="true" aria-current="page" class="current">#{pagy.label_for(item)}</a>)
-                when :gap
-                  %(<a role="link" aria-disabled="true" class="gap">#{pagy_t('pagy.gap')}</a>)
-                else
-                  raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
-                end
-      end
-      html << %(#{next_a(pagy, a)}</nav>)
-    end
-
-    # Similar to I18n.t: just ~18x faster using ~10x less memory
-    # (@pagy_locale explicitly initialized in order to avoid warning)
-    def pagy_t(key, **opts)
-      Pagy::I18n.translate(@pagy_locale ||= nil, key, **opts)
-    end
-
-    private
-
-    def nav_aria_label(pagy, aria_label: nil)
-      aria_label ||= pagy_t('pagy.aria_label.nav', count: pagy.pages)
-      %(aria-label="#{aria_label}")
-    end
-
-    def prev_a(pagy, a, text: pagy_t('pagy.prev'), aria_label: pagy_t('pagy.aria_label.prev'))
-      if (p_prev = pagy.prev)
-        a.(p_prev, text, aria_label:)
-      else
-        %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
-      end
-    end
-
-    def next_a(pagy, a, text: pagy_t('pagy.next'), aria_label: pagy_t('pagy.aria_label.next'))
-      if (p_next = pagy.next)
-        a.(p_next, text, aria_label:)
-      else
-        %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>)
-      end
-    end
-  end
-end