hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/modal/status_component.rb

@@ -0,0 +1,150 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Modal
+    class StatusComponent < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      IconConfig = T.type_alias { [ Symbol, String ] }
+      ICON_CONFIG = T.let({
+        info: [ :info_circle, "#1890ff" ],
+        success: [ :check_circle, "#52c41a" ],
+        error: [ :close_circle, "#ff4d4f" ],
+        warning: [ :warning, "#faad14" ]
+      }.freeze, T::Hash[Symbol, IconConfig])
+
+      sig do
+        params(
+          id: String,
+          title: HakumiComponents::Types::Renderable,
+          message: HakumiComponents::Types::Renderable,
+          open: T::Boolean,
+          ok_text: T.nilable(String),
+          cancel_text: T.nilable(String),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        id:,
+        title: nil,
+        message: nil,
+        open: false,
+        ok_text: nil,
+        cancel_text: nil,
+        **html_options
+      )
+        @id = T.let(id, String)
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @message = T.let(message, HakumiComponents::Types::Renderable)
+        @open = T.let(cast_boolean(open) ? true : false, T::Boolean)
+        @ok_text = ok_text
+        @cancel_text = cancel_text
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        modal = HakumiComponents::Modal::Component.new(
+          id: @id,
+          title: resolved_title,
+          open: @open,
+          closable: false,
+          mask_closable: false,
+          **@html_options
+        )
+        modal.with_footer { footer_buttons }
+
+        render(modal) do
+          content_tag(:div, class: "hakumi-modal-confirm-body-wrapper") do
+            safe_join([
+              icon_element,
+              content_element
+            ])
+          end
+        end
+      end
+
+      private
+
+      sig { returns(Symbol) }
+      def status_type
+        raise NotImplementedError, "subclasses must define status_type"
+      end
+
+      sig { returns(IconConfig) }
+      def icon_config
+        ICON_CONFIG.fetch(status_type)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def resolved_title
+        @title || t_default(:title, default: status_type.to_s.capitalize)
+      end
+
+      sig { returns(String) }
+      def resolved_ok_text
+        @ok_text || t_default(:ok, default: default_ok_text)
+      end
+
+      sig { returns(String) }
+      def resolved_cancel_text
+        @cancel_text || t_default(:cancel, default: "Cancel")
+      end
+
+      sig { returns(String) }
+      def default_ok_text
+        "OK"
+      end
+
+      sig { returns(T::Boolean) }
+      def show_cancel?
+        false
+      end
+
+      sig { returns(Symbol) }
+      def ok_button_type
+        :primary
+      end
+
+      sig { returns(T::Boolean) }
+      def ok_button_danger?
+        false
+      end
+
+      sig { returns(String) }
+      def ok_button_action
+        "close"
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def footer_buttons
+        buttons = T.let([], T::Array[ActiveSupport::SafeBuffer])
+        if show_cancel?
+          buttons << render(HakumiComponents::Button::Component.new(data: { "hakumi-action": "cancel" })) { resolved_cancel_text }
+        end
+        buttons << render(
+          HakumiComponents::Button::Component.new(
+            type: ok_button_type,
+            danger: ok_button_danger?,
+            data: { "hakumi-action": ok_button_action }
+          )
+        ) { resolved_ok_text }
+        safe_join(buttons)
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def icon_element
+        name, color = icon_config
+        render(HakumiComponents::Icon::Component.new(name: name, theme: :filled, color: color, size: 22))
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def content_element
+        content_tag(:div, class: "hakumi-modal-confirm-content") do
+          content_tag(:p, render_value(@message || content))
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/modal/success/component.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Modal
+    module Success
+      class Component < HakumiComponents::Modal::StatusComponent
+        extend T::Sig
+
+        private
+
+        sig { override.returns(Symbol) }
+        def status_type = :success
+      end
+    end
+  end
+end

data/app/components/hakumi_components/modal/warning/component.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Modal
+    module Warning
+      class Component < HakumiComponents::Modal::StatusComponent
+        extend T::Sig
+
+        private
+
+        sig { override.returns(Symbol) }
+        def status_type = :warning
+
+        sig { override.returns(String) }
+        def default_ok_text = "Proceed"
+
+        sig { override.returns(T::Boolean) }
+        def show_cancel? = true
+
+        sig { override.returns(String) }
+        def ok_button_action = "confirm"
+      end
+    end
+  end
+end

data/app/components/hakumi_components/notification/component.rb

@@ -0,0 +1,160 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Notification
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Type = T.type_alias { T.any(Symbol, String) }
+      Placement = T.type_alias { T.any(Symbol, String) }
+      TYPES = T.let(%i[success info warning error].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let(%i[top topLeft topRight bottom bottomLeft bottomRight].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          title: html_primitive_param(html_param(params, :title)) || html_primitive_param(html_param(params, :message)),
+          description: html_primitive_param(html_param(params, :description)),
+          type: symbol_html_param(html_param(params, :type)),
+          duration: float_html_param(html_param(params, :duration)),
+          key: html_primitive_param(html_param(params, :key)),
+          placement: symbol_html_param(html_param(params, :placement)),
+          icon: html_primitive_param(html_param(params, :icon)),
+          close_icon: html_primitive_param(html_param(params, :close_icon)),
+          btn: html_primitive_param(html_param(params, :btn)),
+          max_count: integer_html_param(html_param(params, :max_count)),
+          top: integer_html_param(html_param(params, :top)),
+          bottom: integer_html_param(html_param(params, :bottom)),
+          pause_on_hover: boolean_html_param(html_param(params, :pause_on_hover)),
+          show_progress: boolean_html_param(html_param(params, :show_progress)),
+          stack_threshold: integer_html_param(html_param(params, :stack_threshold))
+        }
+      end
+
+      sig do
+        params(
+          title: HakumiComponents::Types::HtmlPrimitive,
+          description: HakumiComponents::Types::HtmlPrimitive,
+          type: T.nilable(Type),
+          duration: T.nilable(Float),
+          key: HakumiComponents::Types::HtmlPrimitive,
+          placement: T.nilable(Placement),
+          icon: HakumiComponents::Types::HtmlPrimitive,
+          close_icon: HakumiComponents::Types::HtmlPrimitive,
+          btn: HakumiComponents::Types::HtmlPrimitive,
+          max_count: T.nilable(Integer),
+          top: T.nilable(Integer),
+          bottom: T.nilable(Integer),
+          pause_on_hover: T.nilable(T::Boolean),
+          show_progress: T.nilable(T::Boolean),
+          stack_threshold: T.nilable(Integer),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        title: nil,
+        description: nil,
+        type: nil,
+        duration: nil,
+        key: nil,
+        placement: nil,
+        icon: nil,
+        close_icon: nil,
+        btn: nil,
+        max_count: nil,
+        top: nil,
+        bottom: nil,
+        pause_on_hover: nil,
+        show_progress: nil,
+        stack_threshold: nil,
+        **html_options
+      )
+        @title = T.let(title, HakumiComponents::Types::HtmlPrimitive)
+        @description = T.let(description, HakumiComponents::Types::HtmlPrimitive)
+        @type = T.let(type&.to_sym, T.nilable(Symbol))
+        @duration = T.let(duration, T.nilable(Float))
+        @key = T.let(key, HakumiComponents::Types::HtmlPrimitive)
+        @placement = T.let(placement&.to_sym, T.nilable(Symbol))
+        @icon = T.let(icon, HakumiComponents::Types::HtmlPrimitive)
+        @close_icon = T.let(close_icon, HakumiComponents::Types::HtmlPrimitive)
+        @btn = T.let(btn, HakumiComponents::Types::HtmlPrimitive)
+        @max_count = T.let(max_count, T.nilable(Integer))
+        @top = T.let(top, T.nilable(Integer))
+        @bottom = T.let(bottom, T.nilable(Integer))
+        @pause_on_hover = T.let(pause_on_hover, T.nilable(T::Boolean))
+        @show_progress = T.let(show_progress, T.nilable(T::Boolean))
+        @stack_threshold = T.let(stack_threshold, T.nilable(Integer))
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def root_attributes
+        base_attrs = {
+          id: "notification",
+          class: component_classes("notification", {}, @html_options),
+          data: data_attributes
+        }
+
+        merge_attributes(base_attrs, @html_options)
+      end
+
+      sig { returns(HakumiComponents::Types::DataAttributes) }
+      def data_attributes
+        attrs = T.let({
+          controller: "hakumi--notification"
+        }, HakumiComponents::Types::DataAttributes)
+
+        attrs[:hakumi__notification_duration_value] = @duration unless @duration.nil?
+        attrs[:hakumi__notification_max_count_value] = @max_count unless @max_count.nil?
+        attrs[:hakumi__notification_top_value] = @top unless @top.nil?
+        attrs[:hakumi__notification_bottom_value] = @bottom unless @bottom.nil?
+        attrs[:hakumi__notification_placement_value] = @placement if @placement
+        attrs[:hakumi__notification_pause_on_hover_value] = @pause_on_hover unless @pause_on_hover.nil?
+        attrs[:hakumi__notification_show_progress_value] = @show_progress unless @show_progress.nil?
+        attrs[:hakumi__notification_stack_threshold_value] = @stack_threshold unless @stack_threshold.nil?
+
+        payload = initial_payload
+        attrs[:hakumi__notification_payload_value] = payload.to_json if payload.present?
+
+        attrs
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        content_tag(:div, nil, root_attributes)
+      end
+
+      private
+
+      sig { returns(HakumiComponents::Types::StimulusValues) }
+      def initial_payload
+        {
+          title: @title,
+          description: @description,
+          type: @type,
+          duration: @duration,
+          key: @key,
+          placement: @placement,
+          icon: @icon,
+          closeIcon: @close_icon,
+          btn: @btn,
+          pauseOnHover: @pause_on_hover,
+          showProgress: @show_progress
+        }.compact
+      end
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:type, TYPES)
+        validate_inclusion!(:placement, PLACEMENTS)
+      end
+    end
+  end
+end

data/app/components/{hakumi → hakumi_components}/pagination/component.html.erb

@@ -3,7 +3,6 @@
     <li class="hakumi-pagination-total-text"><%= total_text %></li>
   <% end %>
 
-  <%# Previous button %>
   <li
     class="hakumi-pagination-prev<%= ' hakumi-pagination-disabled' if prev_disabled? || disabled %>"
     data-action="click->hakumi--pagination#prev"
@@ -18,7 +17,6 @@
   </li>
 
   <% if simple %>
-    <%# Simple mode: input / total %>
     <li class="hakumi-pagination-simple-pager">
       <input
         type="text"
@@ -32,17 +30,16 @@
       <span class="hakumi-pagination-simple-total"><%= total_pages %></span>
     </li>
   <% else %>
-    <%# Page items %>
     <% page_items.each do |item| %>
-      <% if item[:type] == :page %>
+      <% if item.page? %>
         <li
-          class="hakumi-pagination-item hakumi-pagination-item-<%= item[:number] %><%= ' hakumi-pagination-item-active' if item[:number] == current %>"
-          data-page="<%= item[:number] %>"
+          class="hakumi-pagination-item hakumi-pagination-item-<%= item.number %><%= ' hakumi-pagination-item-active' if item.number == current %>"
+          data-page="<%= item.number %>"
           data-action="click->hakumi--pagination#goToPage"
           data-hakumi--pagination-target="page">
-          <a rel="nofollow"><%= item[:number] %></a>
+          <a rel="nofollow"><%= item.number %></a>
         </li>
-      <% elsif item[:type] == :jump_prev %>
+      <% elsif item.jump_prev? %>
         <li
           class="hakumi-pagination-jump-prev hakumi-pagination-jump-prev-custom-icon"
           data-action="click->hakumi--pagination#jumpPrev"
@@ -54,7 +51,7 @@
             </span>
           </a>
         </li>
-      <% elsif item[:type] == :jump_next %>
+      <% elsif item.jump_next? %>
         <li
           class="hakumi-pagination-jump-next hakumi-pagination-jump-next-custom-icon"
           data-action="click->hakumi--pagination#jumpNext"
@@ -70,7 +67,6 @@
     <% end %>
   <% end %>
 
-  <%# Next button %>
   <li
     class="hakumi-pagination-next<%= ' hakumi-pagination-disabled' if next_disabled? || disabled %>"
     data-action="click->hakumi--pagination#next"
@@ -87,10 +83,10 @@
   <% if show_size_changer? && !simple %>
     <li class="hakumi-pagination-options">
       <div class="hakumi-pagination-options-size-changer" data-hakumi--pagination-target="sizeChanger">
-        <%= render Hakumi::Select::Component.new(
+        <%= render HakumiComponents::Select::Component.new(
           options: page_size_options.map { |size| ["#{size} / page", size] },
           value: page_size,
-          size: :middle,
+          size: :default,
           disabled: disabled,
           standalone: true
         ) %>

data/app/components/hakumi_components/pagination/component.rb

@@ -0,0 +1,238 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Pagination
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      SIZES = %i[default small].freeze
+      ALIGNS = %i[start center end].freeze
+      DEFAULT_PAGE_SIZE_OPTIONS = [ 10, 20, 50, 100 ].freeze
+      ShowTotalProc = T.type_alias { T.proc.params(total: Integer, range: T::Array[Integer]).returns(String) }
+      ShowTotal = T.type_alias { T.nilable(T.any(T::Boolean, String, ShowTotalProc)) }
+
+      sig do
+        params(
+          total: Integer,
+          current: Integer,
+          page_size: Integer,
+          size: Symbol,
+          align: Symbol,
+          disabled: T::Boolean,
+          simple: T::Boolean,
+          show_size_changer: T.nilable(T::Boolean),
+          show_quick_jumper: T::Boolean,
+          show_total: ShowTotal,
+          page_size_options: T::Array[Integer],
+          hide_on_single_page: T::Boolean,
+          prev_text: T.nilable(String),
+          next_text: T.nilable(String),
+          href: T.nilable(String),
+          page_param: Symbol,
+          per_page_param: Symbol,
+          turbo_frame: T.nilable(String),
+          turbo_action: T.nilable(String),
+          preserve_params: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        total:,
+        current: 1,
+        page_size: 10,
+        size: :default,
+        align: :start,
+        disabled: false,
+        simple: false,
+        show_size_changer: nil,
+        show_quick_jumper: false,
+        show_total: nil,
+        page_size_options: DEFAULT_PAGE_SIZE_OPTIONS,
+        hide_on_single_page: false,
+        prev_text: nil,
+        next_text: nil,
+        href: nil,
+        page_param: :page,
+        per_page_param: :per_page,
+        turbo_frame: nil,
+        turbo_action: nil,
+        preserve_params: nil,
+        **html_options
+      )
+        @total = T.let(total, Integer)
+        @current = T.let(current, Integer)
+        @page_size = T.let(page_size, Integer)
+        @size = T.let(size, Symbol)
+        @align = T.let(align, Symbol)
+        @disabled = T.let(disabled, T::Boolean)
+        @simple = T.let(simple, T::Boolean)
+        @show_size_changer = T.let(show_size_changer, T.nilable(T::Boolean))
+        @show_quick_jumper = T.let(show_quick_jumper, T::Boolean)
+        @show_total = T.let(show_total, ShowTotal)
+        @page_size_options = T.let(page_size_options, T::Array[Integer])
+        @hide_on_single_page = T.let(hide_on_single_page, T::Boolean)
+        @prev_text = T.let(prev_text, T.nilable(String))
+        @next_text = T.let(next_text, T.nilable(String))
+        @href = T.let(href, T.nilable(String))
+        @page_param = T.let(page_param, Symbol)
+        @per_page_param = T.let(per_page_param, Symbol)
+        @turbo_frame = T.let(turbo_frame, T.nilable(String))
+        @turbo_action = T.let(turbo_action, T.nilable(String))
+        @preserve_params = T.let(preserve_params, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(T::Boolean) }
+      def render?
+        !(@hide_on_single_page && total_pages <= 1)
+      end
+
+      sig { returns(Integer) }
+      def total_pages
+        (@total.to_f / @page_size).ceil
+      end
+
+      sig { returns(String) }
+      def pagination_classes
+        classes = [ "hakumi-pagination" ]
+        classes << "hakumi-pagination-mini" if @size == :small
+        classes << "hakumi-pagination-simple" if @simple
+        classes << "hakumi-pagination-disabled" if @disabled
+        classes << "hakumi-pagination-align-#{@align}" if @align != :start
+        classes.join(" ")
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        values = T.let({
+          current: @current,
+          page_size: @page_size,
+          total: @total,
+          disabled: @disabled,
+          simple: @simple
+        }, Types::StimulusValues)
+        values[:href] = @href if @href.present?
+        values[:page_param] = @page_param.to_s if @href.present?
+        values[:per_page_param] = @per_page_param.to_s if @href.present?
+        values[:turbo_frame] = @turbo_frame if @turbo_frame.present?
+        values[:turbo_action] = @turbo_action if @turbo_action.present?
+        values[:preserve_params] = @preserve_params if @preserve_params.present?
+
+        merge_attributes(
+          { class: pagination_classes, data: stimulus_attrs("hakumi--pagination", values) },
+          @html_options
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def prev_disabled?
+        @current <= 1
+      end
+
+      sig { returns(T::Boolean) }
+      def next_disabled?
+        @current >= total_pages
+      end
+
+      sig { returns(T::Boolean) }
+      def show_size_changer?
+        return @show_size_changer unless @show_size_changer.nil?
+
+        @total > 50
+      end
+
+      sig { returns(T::Array[HakumiComponents::Pagination::PageItem]) }
+      def page_items
+        return [] if @simple
+
+        items = T.let([], T::Array[HakumiComponents::Pagination::PageItem])
+        total = total_pages
+        current = @current
+
+        items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: 1)
+
+        if total <= 7
+          (2..total).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+        elsif current <= 4
+          (2..5).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_next)
+          items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: total)
+        elsif current >= total - 3
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_prev)
+          ((total - 4)..total).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+        else
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_prev)
+          ((current - 1)..(current + 1)).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_next)
+          items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: total)
+        end
+
+        items
+      end
+
+      sig { returns(HakumiComponents::Icon::Component) }
+      def prev_icon
+        HakumiComponents::Icon::Component.new(name: :left)
+      end
+
+      sig { returns(HakumiComponents::Icon::Component) }
+      def next_icon
+        HakumiComponents::Icon::Component.new(name: :right)
+      end
+
+      sig { returns(HakumiComponents::Icon::Component) }
+      def jump_prev_icon
+        HakumiComponents::Icon::Component.new(name: :double_left)
+      end
+
+      sig { returns(HakumiComponents::Icon::Component) }
+      def jump_next_icon
+        HakumiComponents::Icon::Component.new(name: :double_right)
+      end
+
+      sig { returns(HakumiComponents::Icon::Component) }
+      def ellipsis_icon
+        HakumiComponents::Icon::Component.new(name: :ellipsis)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def total_text
+        return nil unless @show_total
+
+        case @show_total
+        when true
+          t_default(:total, default: "Total %{count} items", count: @total)
+        when String
+          @show_total
+        when Proc
+          start_item = (@current - 1) * @page_size + 1
+          end_item = [ @current * @page_size, @total ].min
+          @show_total.call(@total, [ start_item, end_item ])
+        end
+      end
+
+      sig { returns(Integer) }
+      attr_reader :current, :page_size, :total
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled, :simple, :show_quick_jumper
+
+      sig { returns(T::Array[Integer]) }
+      attr_reader :page_size_options
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :prev_text, :next_text, :href, :turbo_frame, :turbo_action
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:align, ALIGNS)
+      end
+    end
+  end
+end