hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,73 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Dropdown
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            key: String,
+            label: T.nilable(String),
+            href: T.nilable(String),
+            target: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            disabled: T::Boolean,
+            danger: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(key:, label: nil, href: nil, target: nil, icon: nil, disabled: false, danger: false, **html_options)
+          @key = T.let(key, String)
+          @label = T.let(label, T.nilable(String))
+          @href = T.let(href, T.nilable(String))
+          @target = T.let(target, 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)
+          @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
+          classes = T.let([ "hakumi-dropdown-menu-item" ], T::Array[String])
+          classes << "hakumi-dropdown-menu-item-disabled" if disabled
+          classes << "hakumi-dropdown-menu-item-danger" if danger
+          classes.join(" ")
+        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 → hakumi_components}/empty/component.rb

@@ -1,13 +1,19 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Empty
-    class Component < Hakumi::BaseComponent
-      BUILT_IN_IMAGES = [ :default, :simple ].freeze
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Image = T.type_alias { T.any(Symbol, String, ActiveSupport::SafeBuffer, ViewComponent::Base, ViewComponent::Slot) }
+      Description = T.type_alias { T.any(FalseClass, HakumiComponents::Types::Renderable) }
+
+      BUILT_IN_IMAGES = T.let([ :default, :simple ].freeze, T::Array[Symbol])
 
       # Default SVG image matching Ant Design's PRESENTED_IMAGE_DEFAULT
       # Uses CSS classes for dark mode theming
-      DEFAULT_IMAGE_SVG = <<~SVG.html_safe
+      DEFAULT_IMAGE_SVG = T.let(<<~SVG.html_safe, ActiveSupport::SafeBuffer)
         <svg class="hakumi-empty-img-default" width="184" height="152" viewBox="0 0 184 152" xmlns="http://www.w3.org/2000/svg">
           <g fill="none" fill-rule="evenodd">
             <g transform="translate(24 31.67)">
@@ -27,7 +33,7 @@ module Hakumi
       SVG
 
       # Simple SVG image matching Ant Design's PRESENTED_IMAGE_SIMPLE
-      SIMPLE_IMAGE_SVG = <<~SVG.html_safe
+      SIMPLE_IMAGE_SVG = T.let(<<~SVG.html_safe, ActiveSupport::SafeBuffer)
         <svg class="hakumi-empty-img-simple" width="64" height="41" viewBox="0 0 64 41" xmlns="http://www.w3.org/2000/svg">
           <g transform="translate(0 1)" fill="none" fill-rule="evenodd">
             <ellipse class="hakumi-empty-img-simple-ellipse" cx="32" cy="33" rx="32" ry="7"/>
@@ -39,21 +45,32 @@ module Hakumi
         </svg>
       SVG
 
-      DEFAULT_DESCRIPTION = "No data"
+      sig do
+        params(
+          image: Image,
+          image_height: T.nilable(T.any(Integer, String)),
+          description: T.nilable(Description),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(image: :default, image_height: nil, description: nil, **html_options)
+        @image = T.let(image, Image)
+        @image_height = T.let(image_height, T.nilable(T.any(Integer, String)))
+        @description = T.let(description, T.nilable(Description))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
-      def initialize(image: :default, image_height: nil, description: DEFAULT_DESCRIPTION, **html_options)
-        @image = image
-        @image_height = image_height
-        @description = description
-        @html_options = html_options
+        validate_props!
       end
 
-      def call
-        classes = [ "hakumi-empty" ]
-        classes << "hakumi-empty-normal" if @image == :simple
-        classes << @html_options[:class] if @html_options[:class].present?
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def resolved_description
+        return nil if @description == false
+        @description || t_default(:description, default: "No data")
+      end
 
-        content_tag(:div, class: classes.join(" "), **@html_options.except(:class)) do
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        content_tag(:div, wrapper_attributes) do
           safe_join([
             image_element,
             description_element,
@@ -62,48 +79,66 @@ module Hakumi
         end
       end
 
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("empty", { normal: @image == :simple }, @html_options)
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+      end
+
       private
 
+      sig { void }
+      def validate_props!
+        return unless @image.is_a?(Symbol)
+        return if BUILT_IN_IMAGES.include?(@image)
+
+        raise ArgumentError, "image must be one of #{BUILT_IN_IMAGES.inspect}, got #{@image.inspect}"
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
       def image_element
-        image_style = @image_height ? "height: #{@image_height}px" : nil
+        image_style = dimension_to_css(@image_height)
 
-        tag.div(class: "hakumi-empty-image", style: image_style) do
-          render_image
-        end
+        content_tag(:div, render_image, class: "hakumi-empty-image", style: image_style ? "height: #{image_style};" : nil)
       end
 
+      sig { returns(HakumiComponents::Types::RenderedContent) }
       def render_image
-        case @image
-        when :default
+        if @image == :default
           DEFAULT_IMAGE_SVG
-        when :simple
+        elsif @image == :simple
           SIMPLE_IMAGE_SVG
-        when String
+        elsif @image.is_a?(ViewComponent::Base) || @image.is_a?(ViewComponent::Slot) || @image.is_a?(ActiveSupport::SafeBuffer)
+          render_value(@image)
+        elsif @image.is_a?(String)
           tag.img(src: @image, alt: image_alt, draggable: false)
         else
-          # Assume it's renderable content (ViewComponent or other)
-          @image
+          nil
         end
       end
 
+      sig { returns(String) }
       def image_alt
-        @description.is_a?(String) ? @description : "empty"
+        desc = resolved_description
+        desc.is_a?(String) ? desc : "empty"
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def description_element
         return nil if @description == false
 
-        tag.div(class: "hakumi-empty-description") do
-          @description
-        end
+        content_tag(:div, render_value(resolved_description), class: "hakumi-empty-description")
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def footer_element
         return nil unless content.present?
 
-        tag.div(class: "hakumi-empty-footer") do
-          content
-        end
+        content_tag(:div, render_value(content), class: "hakumi-empty-footer")
       end
     end
   end

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

@@ -0,0 +1,96 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Flex
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      PropValue = T.type_alias { T.nilable(T.any(Symbol, Numeric, String)) }
+
+      WRAPS = T.let([ :wrap, :nowrap, :"wrap-reverse" ].freeze, T::Array[Symbol])
+      JUSTIFY_VALUES = T.let([ :start, :end, :center, :"space-between", :"space-around", :"space-evenly" ].freeze, T::Array[Symbol])
+      ALIGN_VALUES = T.let([ :start, :end, :center, :baseline, :stretch ].freeze, T::Array[Symbol])
+      GAPS = T.let([ :small, :default, :large ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          vertical: T::Boolean,
+          wrap: PropValue,
+          justify: PropValue,
+          align: PropValue,
+          gap: PropValue,
+          component: Symbol,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        vertical: false,
+        wrap: :nowrap,
+        justify: :start,
+        align: :start,
+        gap: nil,
+        component: :div,
+        **html_options
+      )
+        @vertical = T.let(vertical, T::Boolean)
+        @wrap = T.let(normalize_prop(wrap), PropValue)
+        @justify = T.let(normalize_prop(justify), PropValue)
+        @align = T.let(align, PropValue)
+        @gap = T.let(gap, PropValue)
+        @component = T.let(component, Symbol)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        content_tag(@component, content, wrapper_attributes)
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:wrap, WRAPS) if @wrap.is_a?(Symbol)
+        validate_inclusion!(:justify, JUSTIFY_VALUES)
+        validate_inclusion!(:align, ALIGN_VALUES)
+        validate_inclusion!(:gap, GAPS) if @gap.is_a?(Symbol)
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        class_names(
+          "flex",
+          {
+            vertical: @vertical,
+            "wrap-#{@wrap}": @wrap != :nowrap,
+            "justify-#{@justify}": @justify != :start,
+            "align-#{@align}": @align != :start,
+            "gap-#{@gap}": @gap.is_a?(Symbol)
+          },
+          html_classes(@html_options)
+        )
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def wrapper_attributes
+        attrs = T.let({ class: wrapper_classes }, HakumiComponents::Types::HtmlAttributes)
+
+        if @gap.present? && !@gap.is_a?(Symbol)
+          attrs[:style] = "gap: #{@gap.is_a?(Numeric) ? "#{@gap}px" : @gap};"
+        end
+
+        merge_attributes(attrs, @html_options.except(:class))
+      end
+
+      sig { params(prop: PropValue).returns(PropValue) }
+      def normalize_prop(prop)
+        return prop unless prop.is_a?(Symbol)
+
+        prop.to_s.tr("_", "-").to_sym
+      end
+    end
+  end
+end

data/app/components/hakumi_components/float_button/back_top/component.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module FloatButton
+    module BackTop
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        DEFAULT_VISIBILITY = 400
+
+        sig do
+          params(
+            icon: HakumiComponents::FloatButton::Component::IconValue,
+            tooltip: String,
+            visibility_height: Integer,
+            target_selector: T.nilable(String),
+            floating: T::Boolean,
+            placement: Symbol,
+            offset: T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap),
+            button_options: Types::HtmlAttributes,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          icon: :vertical_align_top,
+          tooltip: "Back to top",
+          visibility_height: DEFAULT_VISIBILITY,
+          target_selector: nil,
+          floating: true,
+          placement: :bottom_right,
+          offset: nil,
+          button_options: {},
+          **html_options
+        )
+          @icon = T.let(icon, HakumiComponents::FloatButton::Component::IconValue)
+          @tooltip = T.let(tooltip, String)
+          @visibility_height = T.let(visibility_height, Integer)
+          @target_selector = T.let(target_selector, T.nilable(String))
+          @floating = T.let(floating, T::Boolean)
+          @placement = T.let(placement, Symbol)
+          @offset = T.let(offset, T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap))
+          @button_options = T.let(button_options, Types::HtmlAttributes)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def call
+          render HakumiComponents::FloatButton::Component.new(
+            icon: @icon,
+            tooltip: @tooltip,
+            floating: @floating,
+            placement: @placement,
+            offset: @offset,
+            button_options: back_top_button_options,
+            **back_top_html_options
+          )
+        end
+
+        private
+
+        sig { returns(Types::HtmlAttributes) }
+        def back_top_html_options
+          options = @html_options.deep_dup
+          options[:class] = class_names("float-button-back-top", {}, html_classes(@html_options))
+
+          data = data_attributes_from(options[:data])
+          data[:controller] = append_data_token(data[:controller], "hakumi--back-top")
+          data["hakumi--back-top-visibility-height-value"] = @visibility_height
+          data["hakumi--back-top-target-selector-value"] = @target_selector if @target_selector.present?
+          options[:data] = data
+          options
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def back_top_button_options
+          options = @button_options.deep_dup
+          data = data_attributes_from(options[:data])
+          data[:action] = append_data_token(data[:action], "click->hakumi--back-top#scroll")
+          options[:data] = data
+          options
+        end
+      end
+    end
+  end
+end