hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/menu/item/component.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Menu
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            key: String,
+            label: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            disabled: T::Boolean,
+            danger: T::Boolean,
+            href: T.nilable(String),
+            target: T.nilable(String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(key:, label: nil, icon: nil, disabled: false, danger: false, href: nil, target: nil, **html_options)
+          @key = T.let(key, String)
+          @label = T.let(label, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @disabled = T.let(disabled, T::Boolean)
+          @danger = T.let(danger, T::Boolean)
+          @href = T.let(href, T.nilable(String))
+          @target = T.let(target, T.nilable(String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(String) }
+        attr_reader :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label, :href, :target
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled, :danger
+
+        sig { returns(String) }
+        def item_classes
+          class_names("menu-item", { disabled: disabled, danger: danger })
+        end
+
+        sig { returns(T::Boolean) }
+        def link?
+          href.present?
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def display_label
+          content.presence || label
+        end
+
+        sig { returns(T.nilable(ViewComponent::Base)) }
+        def icon_component
+          ic = @icon
+          return nil if ic.nil?
+
+          ic.is_a?(Symbol) ? HakumiComponents::Icon::Component.new(name: ic) : ic
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/menu/sub_menu/component.rb

@@ -0,0 +1,104 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Menu
+    module SubMenu
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        renders_many :items, types: {
+          item: {
+            renders: HakumiComponents::Menu::Item::Component,
+            as: :item
+          },
+          submenu: {
+            renders: ->(key:, label: nil, icon: nil, disabled: false) do
+              T.bind(self, HakumiComponents::Menu::SubMenu::Component)
+              HakumiComponents::Menu::SubMenu::Component.new(
+                key: key,
+                label: label,
+                icon: icon,
+                disabled: disabled,
+                mode: mode
+              )
+            end,
+            as: :submenu
+          },
+          group: {
+            renders: HakumiComponents::Menu::Group::Component,
+            as: :group
+          },
+          divider: {
+            renders: -> { HakumiComponents::Menu::Divider::Component.new },
+            as: :divider
+          }
+        }
+
+        sig do
+          params(
+            key: String,
+            label: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            disabled: T::Boolean,
+            mode: Symbol,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(key:, label: nil, icon: nil, disabled: false, mode: :vertical, **html_options)
+          @key = T.let(key, String)
+          @label = T.let(label, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @disabled = T.let(disabled, T::Boolean)
+          @mode = T.let(mode, Symbol)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(String) }
+        attr_reader :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled
+
+        sig { returns(Symbol) }
+        attr_reader :mode
+
+        sig { returns(String) }
+        def submenu_classes
+          modifiers = T.let({ disabled: disabled }, Types::ClassModifiers)
+          modifiers[popup? ? :popup : :inline] = true
+          class_names("menu-submenu", modifiers)
+        end
+
+        sig { returns(String) }
+        def title_classes
+          "hakumi-menu-submenu-title"
+        end
+
+        sig { returns(T::Boolean) }
+        def popup?
+          mode != :inline
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def display_label
+          content.presence || label
+        end
+
+        sig { returns(T.nilable(ViewComponent::Base)) }
+        def icon_component
+          ic = @icon
+          return nil if ic.nil?
+
+          ic.is_a?(Symbol) ? HakumiComponents::Icon::Component.new(name: ic) : ic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Message
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Type = T.type_alias { T.any(Symbol, String) }
+      TYPES = T.let(%i[success info warning error loading].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)
+        {
+          message: html_primitive_param(html_param(params, :message)) || "Generated message content.",
+          type: symbol_html_param(html_param(params, :type)),
+          duration: float_html_param(html_param(params, :duration)),
+          key: html_primitive_param(html_param(params, :key)),
+          icon: html_primitive_param(html_param(params, :icon)),
+          closable: boolean_html_param(html_param(params, :closable)),
+          max_count: integer_html_param(html_param(params, :max_count)),
+          top: integer_html_param(html_param(params, :top))
+        }
+      end
+
+      sig do
+        params(
+          message: HakumiComponents::Types::HtmlPrimitive,
+          type: T.nilable(Type),
+          duration: T.nilable(Numeric),
+          key: HakumiComponents::Types::HtmlPrimitive,
+          icon: HakumiComponents::Types::HtmlPrimitive,
+          closable: T::Boolean,
+          max_count: T.nilable(Integer),
+          top: T.nilable(Integer),
+          close_label: T.nilable(String),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        message: nil,
+        type: nil,
+        duration: 3.0,
+        key: nil,
+        icon: nil,
+        closable: false,
+        max_count: nil,
+        top: nil,
+        # i18n
+        close_label: nil,
+        **html_options
+      )
+        @message = T.let(message, HakumiComponents::Types::HtmlPrimitive)
+        @type = T.let(type&.to_sym, T.nilable(Symbol))
+        @duration = T.let(duration.nil? ? 3.0 : duration.to_f, Float)
+        @key = T.let(key, HakumiComponents::Types::HtmlPrimitive)
+        @icon = T.let(icon, HakumiComponents::Types::HtmlPrimitive)
+        @closable = T.let(closable, T::Boolean)
+        @max_count = T.let(max_count, T.nilable(Integer))
+        @top = T.let(top, T.nilable(Integer))
+        @close_label = T.let(close_label, T.nilable(String))
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def root_attributes
+        base_attrs = {
+          class: wrapper_classes,
+          data: data_attributes,
+          role: "status",
+          "aria-live": "polite",
+          "aria-atomic": "true"
+        }
+
+        base_attrs[:style] = inline_style if inline_style
+
+        merge_attributes(base_attrs, @html_options)
+      end
+
+      sig { returns(HakumiComponents::Types::DataAttributes) }
+      def data_attributes
+        attrs = T.let({
+          controller: "hakumi--message",
+          hakumi__message_duration_value: @duration,
+          hakumi__message_max_count_value: @max_count,
+          hakumi__message_top_value: @top,
+          hakumi__message_close_label_value: close_label_text
+        }, HakumiComponents::Types::DataAttributes)
+
+        payload = initial_payload
+        attrs[:hakumi__message_payload_value] = payload.to_json if payload.present?
+
+        attrs
+      end
+
+      sig { returns(String) }
+      def close_label_text
+        @close_label || t_default(:close, default: "Close")
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("message", {}, @html_options)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def inline_style
+        styles = T.let([], T::Array[String])
+        styles << "--hakumi-message-top: #{@top}px" if @top
+        styles.join("; ") if styles.any?
+      end
+
+      private
+
+      sig { returns(HakumiComponents::Types::StimulusValues) }
+      def initial_payload
+        payload = {
+          message: @message,
+          type: @type,
+          duration: @duration,
+          key: @key,
+          icon: @icon,
+          closable: @closable
+        }.compact
+
+        payload.presence
+      end
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:type, TYPES)
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-<%= content_tag(:div, class: classes, style: style, data: data_attributes, **@html_attributes.except(:class, :style, :data)) do %>
+<%= content_tag(:div, class: wrapper_classes, style: wrapper_style, data: data_attributes, **@html_options.except(:class, :style, :data)) do %>
   <% if @mask %>
     <div class="hakumi-modal-mask" data-hakumi--modal-target="mask" data-action="click->hakumi--modal#handleMaskClick"></div>
   <% end %>
@@ -9,18 +9,18 @@
         <% if @closable %>
           <button type="button" class="hakumi-modal-close" aria-label="Close" data-hakumi-action="close">
             <span class="hakumi-modal-close-x">
-              <%= render Hakumi::Icon::Component.new(name: :close) %>
+              <%= render HakumiComponents::Icon::Component.new(name: :close) %>
             </span>
           </button>
         <% end %>
 
         <% if render_header? %>
           <div class="hakumi-modal-header">
-            <% if header? %>
-              <div class="hakumi-modal-title"><%= header %></div>
+            <% if header_content.present? %>
+              <div class="hakumi-modal-title"><%= header_content %></div>
             <% end %>
-            <% if extra? %>
-              <div class="hakumi-modal-extra"><%= extra %></div>
+            <% if extra_content.present? %>
+              <div class="hakumi-modal-extra"><%= extra_content %></div>
             <% end %>
           </div>
         <% end %>
@@ -31,7 +31,7 @@
 
         <% if render_footer? %>
           <div class="hakumi-modal-footer">
-            <%= footer %>
+            <%= footer_content %>
           </div>
         <% end %>
       </div>

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

@@ -0,0 +1,152 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Modal
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      renders_one :header
+      renders_one :body
+      renders_one :footer
+      renders_one :extra
+
+      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)),
+          message: html_primitive_param(html_param(params, :message)),
+          open: boolean_html_param(html_param(params, :open)),
+          width: integer_html_param(html_param(params, :width)),
+          centered: boolean_html_param(html_param(params, :centered)),
+          closable: boolean_html_param(html_param(params, :closable)),
+          mask: boolean_html_param(html_param(params, :mask)),
+          mask_closable: boolean_html_param(html_param(params, :mask_closable)),
+          keyboard: boolean_html_param(html_param(params, :keyboard)),
+          confirm_loading: boolean_html_param(html_param(params, :confirm_loading))
+        }
+      end
+
+      sig do
+        params(
+          title: HakumiComponents::Types::Renderable,
+          message: HakumiComponents::Types::Renderable,
+          open: T::Boolean,
+          width: T.any(Integer, String),
+          centered: T::Boolean,
+          closable: T::Boolean,
+          mask: T::Boolean,
+          mask_closable: T::Boolean,
+          keyboard: T::Boolean,
+          confirm_loading: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        title: nil,
+        message: nil,
+        open: false,
+        width: 520,
+        centered: false,
+        closable: true,
+        mask: true,
+        mask_closable: true,
+        keyboard: true,
+        confirm_loading: false,
+        **html_options
+      )
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @message = T.let(message, HakumiComponents::Types::Renderable)
+        @open = T.let(cast_boolean(open) ? true : false, T::Boolean)
+        @width = T.let(width, T.any(Integer, String))
+        @centered = T.let(cast_boolean(centered) ? true : false, T::Boolean)
+        @closable = T.let(cast_boolean(closable) != false, T::Boolean)
+        @mask = T.let(cast_boolean(mask) != false, T::Boolean)
+        @mask_closable = T.let(cast_boolean(mask_closable) != false, T::Boolean)
+        @keyboard = T.let(cast_boolean(keyboard) != false, T::Boolean)
+        @confirm_loading = T.let(cast_boolean(confirm_loading) ? true : false, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+      end
+
+      private
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("modal-root", {}, @html_options)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def wrapper_style
+        html_style(@html_options)
+      end
+
+      sig { returns(HakumiComponents::Types::DataAttributes) }
+      def data_attributes
+        defaults = T.let({
+          controller: "hakumi--modal",
+          hakumi__modal_open_value: @open,
+          hakumi__modal_mask_closable_value: @mask_closable,
+          hakumi__modal_keyboard_value: @keyboard,
+          hakumi__modal_confirm_loading_value: @confirm_loading
+        }, HakumiComponents::Types::DataAttributes)
+        extra = @html_options[:data]
+        return defaults unless extra.is_a?(Hash)
+
+        defaults.merge(extra)
+      end
+
+      sig { returns(String) }
+      def modal_classes
+        class_names("modal", { centered: @centered })
+      end
+
+      sig { returns(String) }
+      def modal_style
+        "width: #{dimension_to_css(@width)};"
+      end
+
+      sig { returns(T::Boolean) }
+      def render_header?
+        header? || value_present?(@title) || @closable || extra?
+      end
+
+      sig { returns(T::Boolean) }
+      def render_footer?
+        footer?
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def header_content
+        return render_value(header) if header?
+
+        render_value(@title)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def extra_content
+        return render_value(extra) if extra?
+
+        nil
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def footer_content
+        return render_value(footer) if footer?
+
+        nil
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def body_content
+        return render_value(body) if body?
+        return render_value(content) if content.present?
+
+        render_value(@message)
+      end
+    end
+  end
+end

data/app/components/hakumi_components/modal/confirm/component.html.erb

@@ -0,0 +1,23 @@
+<%= render HakumiComponents::Modal::Component.new(
+  id: @id,
+  open: @open,
+  mask_closable: false,
+  closable: false,
+  **@html_options
+) do |modal| %>
+  <% modal.with_header do %>
+    <%= render_value(resolved_title) %>
+  <% end %>
+
+  <div class="hakumi-modal-confirm-body-wrapper">
+    <%= render HakumiComponents::Icon::Component.new(name: icon_name, theme: :filled, color: icon_color, size: 22) %>
+    <div class="hakumi-modal-confirm-content">
+      <p><%= content %></p>
+    </div>
+  </div>
+
+  <% modal.with_footer do %>
+    <%= render(HakumiComponents::Button::Component.new(data: { "hakumi-action": "cancel" })) { "Cancel" } %>
+    <%= render(HakumiComponents::Button::Component.new(type: :primary, data: { "hakumi-action": "confirm" })) { "OK" } %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Modal
+    module Confirm
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        Type = T.type_alias { T.any(Symbol, String) }
+        TYPES = T.let(%i[confirm info success error warning].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)
+          {
+            open: boolean_html_param(html_param(params, :open)),
+            title: html_primitive_param(html_param(params, :title)),
+            type: symbol_html_param(html_param(params, :type))
+          }.compact
+        end
+
+        sig do
+          params(
+            id: String,
+            open: T::Boolean,
+            title: HakumiComponents::Types::Renderable,
+            type: Type,
+            html_options: HakumiComponents::Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          id:,
+          open: false,
+          title: nil,
+          type: :confirm,
+          **html_options
+        )
+          @id = T.let(id, String)
+          @open = T.let(cast_boolean(open) ? true : false, T::Boolean)
+          @title = T.let(title, HakumiComponents::Types::Renderable)
+          @type = T.let(type.to_sym, Symbol)
+          @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+          validate_props!
+        end
+
+        sig { returns(HakumiComponents::Types::Renderable) }
+        def resolved_title
+          @title || t_default(:title, default: "Confirm")
+        end
+
+        private
+
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:type, TYPES)
+        end
+
+        sig { returns(Symbol) }
+        def icon_name
+          case @type
+          when :info then :info_circle
+          when :success then :check_circle
+          when :error then :close_circle
+          when :warning then :exclamation_circle
+          else :exclamation_circle
+          end
+        end
+
+        sig { returns(String) }
+        def icon_color
+          case @type
+          when :info then "#1890ff"
+          when :success then "#52c41a"
+          when :error then "#ff4d4f"
+          when :warning then "#faad14"
+          else "#faad14"
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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