hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,60 +1,73 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module FloatButton
     module GroupCluster
       class Component < HakumiComponents::BaseComponent
-        DIRECTIONS = [ :horizontal, :vertical ].freeze
-        GAP_SIZES = {
+        extend T::Sig
+
+        DIRECTIONS = T.let([ :horizontal, :vertical ].freeze, T::Array[Symbol])
+        GAP_SIZES = T.let({
           small: "8px",
-          middle: "16px",
+          default: "16px",
           large: "24px"
-        }.freeze
-
-        PLACEMENTS = HakumiComponents::FloatButton::Component::PLACEMENTS
-
+        }.freeze, T::Hash[Symbol, String])
+
+        PLACEMENTS = HakumiComponents::FloatButton::PositionConfig::PLACEMENTS
+
+        sig do
+          params(
+            groups: T::Array[T.any(HakumiComponents::FloatButton::GroupSpec::InputAttributes, HakumiComponents::Types::Renderable, HakumiComponents::FloatButton::GroupSpec::RenderFactory, HakumiComponents::FloatButton::GroupSpec)],
+            placement: Symbol,
+            offset: T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap),
+            direction: Symbol,
+            gap: T.any(Symbol, Numeric, String),
+            floating: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           groups:,
           placement: :bottom_right,
           offset: nil,
           direction: :horizontal,
-          gap: :middle,
+          gap: :default,
           floating: true,
           **html_options
         )
-          @groups = Array(groups)
-          @placement = placement
-          @offset = offset
-          @direction = direction
-          @gap = gap
-          @floating = floating
-          @html_options = html_options
+          @groups = T.let(HakumiComponents::FloatButton::GroupSpec.coerce_all(Array(groups)), T::Array[HakumiComponents::FloatButton::GroupSpec])
+          @direction = T.let(direction, Symbol)
+          @gap = T.let(gap, T.any(Symbol, Numeric, String))
+          @position = T.let(HakumiComponents::FloatButton::PositionConfig.new(floating: floating, placement: placement, offset: offset), HakumiComponents::FloatButton::PositionConfig)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_inclusion!(:direction, DIRECTIONS)
-          validate_inclusion!(:placement, PLACEMENTS.keys)
           validate_gap_symbol!
         end
 
+        sig { returns(Types::RenderedContent) }
         def call
           return "" if @groups.empty?
 
           content_tag(:div, cluster_attributes) do
-            safe_join(@groups.map { |group_attrs| render_group(group_attrs) })
+            safe_join(@groups.map { |group_spec| render_group(group_spec) })
           end
         end
 
         private
 
+        sig { returns(Types::HtmlAttributes) }
         def cluster_attributes
-          base_attrs = {
+          base_attrs = T.let({
             class: class_names(
               "float-button-group-cluster",
               {
                 "direction-#{@direction}": true,
-                static: !@floating
+                static: !@position.floating
               }
             )
-          }
+          }, Types::HtmlAttributes)
 
           style_value = cluster_style
           base_attrs[:style] = style_value if style_value.present?
@@ -64,20 +77,18 @@ module HakumiComponents
           end
         end
 
+        sig { returns(T.nilable(String)) }
         def cluster_style
           styles = [ placement_style, gap_style ].compact
           styles.join("; ").presence
         end
 
+        sig { returns(T.nilable(String)) }
         def placement_style
-          return nil unless @floating
-
-          resolved = resolved_offset
-          segments = [ "position: fixed", "z-index: 1000" ]
-          resolved.each { |key, value| segments << "#{key}: #{dimension(value)}" }
-          segments.join("; ")
+          @position.style
         end
 
+        sig { returns(T.nilable(String)) }
         def gap_style
           value = case @gap
           when Symbol then GAP_SIZES[@gap]
@@ -90,45 +101,26 @@ module HakumiComponents
           "gap: #{value}"
         end
 
-        def resolved_offset
-          placement_offset = PLACEMENTS[@placement] || PLACEMENTS[:bottom_right]
-          custom_offset = @offset || {}
-          placement_offset.merge(custom_offset).compact
-        end
-
-        def dimension(value)
-          return value if value.is_a?(String)
-
-          "#{value}px"
-        end
-
+        sig { params(group_spec: HakumiComponents::FloatButton::GroupSpec).returns(ActiveSupport::SafeBuffer) }
         def render_group(group_spec)
           content_tag(:div, class: "hakumi-float-button-group-cluster-item") do
             render_group_content(group_spec)
           end
         end
 
+        sig { params(group_spec: HakumiComponents::FloatButton::GroupSpec).returns(ActiveSupport::SafeBuffer) }
         def render_group_content(group_spec)
-          return render(group_spec) if renderable_component?(group_spec)
-          return render_group_content(group_spec.call) if group_spec.respond_to?(:call)
-
-          unless group_spec.is_a?(Hash)
-            raise ArgumentError, "Expected group definition to be a Hash or renderable component"
-          end
+          renderable = group_spec.resolve_renderable
+          return render(renderable) if renderable
 
-          normalized = group_spec.deep_symbolize_keys
-          content_block = normalized.delete(:content)
-
-          normalized[:floating] = false unless normalized.key?(:floating)
-
-          component = HakumiComponents::FloatButton::Group::Component.new(**normalized)
-          content_block ? render(component, &content_block) : render(component)
-        end
+          component = group_spec.build_group_component
+          content_block = group_spec.content
+          return render(component) unless content_block
 
-        def renderable_component?(object)
-          object.respond_to?(:render_in)
+          render(component) { content_block.call }
         end
 
+        sig { void }
         def validate_gap_symbol!
           return unless @gap.is_a?(Symbol)
 

data/app/components/hakumi_components/float_button/group_spec.rb

@@ -0,0 +1,259 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module FloatButton
+    class GroupSpec
+      extend T::Sig
+
+      RenderFactory = T.type_alias { T.proc.returns(Types::Renderable) }
+      ItemInput = T.type_alias { T.any(HakumiComponents::FloatButton::ItemSpec::InputAttributes, HakumiComponents::FloatButton::ItemSpec) }
+      GroupInput = T.type_alias { T.any(InputAttributes, Types::Renderable, RenderFactory, HakumiComponents::FloatButton::GroupSpec) }
+      InputValue = T.type_alias do
+        T.nilable(T.any(
+          Types::ValidationPrimitive,
+          Types::Renderable,
+          Types::HtmlAttributes,
+          RenderFactory,
+          T::Array[ItemInput]
+        ))
+      end
+      InputAttributes = T.type_alias { T::Hash[Symbol, InputValue] }
+
+      sig do
+        params(
+          icon: HakumiComponents::FloatButton::Component::IconValue,
+          tooltip: T.nilable(String),
+          shape: Symbol,
+          type: Symbol,
+          trigger: Symbol,
+          open: T.nilable(T::Boolean),
+          default_open: T::Boolean,
+          expand_direction: Symbol,
+          items: T::Array[HakumiComponents::FloatButton::ItemSpec],
+          floating: T::Boolean,
+          placement: Symbol,
+          offset: T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap),
+          button_options: Types::HtmlAttributes,
+          html_options: Types::HtmlAttributes,
+          content: T.nilable(RenderFactory),
+          renderable: Types::Renderable,
+          render_factory: T.nilable(RenderFactory)
+        ).void
+      end
+      def initialize(
+        icon: :plus,
+        tooltip: nil,
+        shape: :circle,
+        type: :default,
+        trigger: :click,
+        open: nil,
+        default_open: false,
+        expand_direction: :top,
+        items: [],
+        floating: false,
+        placement: :bottom_right,
+        offset: nil,
+        button_options: {},
+        html_options: {},
+        content: nil,
+        renderable: nil,
+        render_factory: nil
+      )
+        @icon = T.let(icon, HakumiComponents::FloatButton::Component::IconValue)
+        @tooltip = T.let(tooltip, T.nilable(String))
+        @shape = T.let(shape, Symbol)
+        @type = T.let(type, Symbol)
+        @trigger = T.let(trigger, Symbol)
+        @open = T.let(open, T.nilable(T::Boolean))
+        @default_open = T.let(default_open, T::Boolean)
+        @expand_direction = T.let(expand_direction, Symbol)
+        @items = T.let(items, T::Array[HakumiComponents::FloatButton::ItemSpec])
+        @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)
+        @content = T.let(content, T.nilable(RenderFactory))
+        @renderable = T.let(renderable, Types::Renderable)
+        @render_factory = T.let(render_factory, T.nilable(RenderFactory))
+      end
+
+      sig { returns(Types::Renderable) }
+      attr_reader :renderable
+
+      sig { returns(T.nilable(RenderFactory)) }
+      attr_reader :content
+
+      sig { returns(T.nilable(Types::Renderable)) }
+      def resolve_renderable
+        return @renderable if @renderable
+        return @render_factory.call if @render_factory
+
+        nil
+      end
+
+      sig { returns(HakumiComponents::FloatButton::Group::Component) }
+      def build_group_component
+        HakumiComponents::FloatButton::Group::Component.new(
+          icon: @icon,
+          tooltip: @tooltip,
+          shape: @shape,
+          type: @type,
+          trigger: @trigger,
+          open: @open,
+          default_open: @default_open,
+          expand_direction: @expand_direction,
+          items: @items,
+          floating: @floating,
+          placement: @placement,
+          offset: @offset,
+          button_options: @button_options,
+          **@html_options
+        )
+      end
+
+      sig { params(groups: T::Array[GroupInput]).returns(T::Array[HakumiComponents::FloatButton::GroupSpec]) }
+      def self.coerce_all(groups)
+        groups.map { |group| coerce(group) }
+      end
+
+      sig { params(group: GroupInput).returns(HakumiComponents::FloatButton::GroupSpec) }
+      def self.coerce(group)
+        return group if group.is_a?(HakumiComponents::FloatButton::GroupSpec)
+        renderable = coerce_renderable(group)
+        return new(renderable: renderable) if renderable
+        return new(render_factory: group) if group.is_a?(Proc)
+
+        raise ArgumentError, "Expected group definition to be a Hash, proc, or renderable component" unless group.is_a?(Hash)
+
+        normalized = group.deep_symbolize_keys
+
+        new(
+          icon: coerce_icon(normalized[:icon]),
+          tooltip: coerce_string(normalized[:tooltip]),
+          shape: coerce_symbol(normalized[:shape]) || :circle,
+          type: coerce_symbol(normalized[:type]) || :default,
+          trigger: coerce_symbol(normalized[:trigger]) || :click,
+          open: coerce_boolean(normalized[:open]),
+          default_open: normalized[:default_open] == true,
+          expand_direction: coerce_symbol(normalized[:expand_direction]) || :top,
+          items: HakumiComponents::FloatButton::ItemSpec.coerce_all(coerce_items(normalized[:items])),
+          floating: normalized[:floating] == true,
+          placement: coerce_symbol(normalized[:placement]) || :bottom_right,
+          offset: coerce_offset_map(normalized[:offset]),
+          button_options: coerce_html_attributes(normalized[:button_options]),
+          html_options: coerce_html_options(normalized.except(
+            :icon, :tooltip, :shape, :type, :trigger, :open, :default_open,
+            :expand_direction, :items, :floating, :placement, :offset,
+            :button_options, :content
+          )),
+          content: coerce_render_factory(normalized[:content])
+        )
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: GroupInput).returns(Types::Renderable) }
+        def coerce_renderable(value)
+          return value if value.is_a?(String)
+          return value if value.is_a?(ViewComponent::Base)
+          return value if value.is_a?(ViewComponent::Slot)
+
+          nil
+        end
+
+        sig { params(value: InputValue).returns(HakumiComponents::FloatButton::Component::IconValue) }
+        def coerce_icon(value)
+          return value if value.is_a?(String)
+          return value if value.is_a?(Symbol)
+          return value if value.is_a?(ViewComponent::Base)
+          return value if value.is_a?(ViewComponent::Slot)
+
+          nil
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(String)) }
+        def coerce_string(value)
+          value.is_a?(String) ? value : nil
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(Symbol)) }
+        def coerce_symbol(value)
+          value.is_a?(Symbol) ? value : nil
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(T::Boolean)) }
+        def coerce_boolean(value)
+          value == true || value == false ? value : nil
+        end
+
+        sig { params(value: InputValue).returns(Types::HtmlAttributes) }
+        def coerce_html_attributes(value)
+          value.is_a?(Hash) ? value : {}
+        end
+
+        sig { params(value: InputAttributes).returns(Types::HtmlAttributes) }
+        def coerce_html_options(value)
+          html_options = T.let({}, Types::HtmlAttributes)
+          value.each do |key, attribute_value|
+            coerced = coerce_html_attribute_value(attribute_value)
+            html_options[key] = coerced unless coerced.nil?
+          end
+          html_options
+        end
+
+        sig { params(value: InputValue).returns(Types::HtmlAttributeValue) }
+        def coerce_html_attribute_value(value)
+          return value if value.is_a?(String)
+          return value if value.is_a?(Symbol)
+          return value if value == true || value == false
+          return value if value.is_a?(Numeric)
+
+          if value.is_a?(Hash)
+            data = T.let({}, T::Hash[Types::HtmlKey, Types::HtmlPrimitive])
+            value.each do |key, item|
+              return nil unless item.nil? || item.is_a?(String) || item.is_a?(Symbol) || item == true || item == false || item.is_a?(Numeric)
+
+              data[key] = item
+            end
+            return data
+          end
+
+          nil
+        end
+
+        sig { params(value: InputValue).returns(T::Array[ItemInput]) }
+        def coerce_items(value)
+          return value if value.is_a?(Array)
+
+          []
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap)) }
+        def coerce_offset_map(value)
+          return nil unless value.is_a?(Hash)
+
+          offset = T.let({}, HakumiComponents::FloatButton::PositionConfig::OffsetMap)
+          [ :top, :right, :bottom, :left ].each do |side|
+            next unless value.key?(side)
+
+            amount = value[side]
+            next unless amount.is_a?(Integer) || amount.is_a?(String)
+
+            offset[side] = amount
+          end
+          offset
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(RenderFactory)) }
+        def coerce_render_factory(value)
+          value.is_a?(Proc) ? value : nil
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/float_button/item_spec.rb

@@ -0,0 +1,115 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module FloatButton
+    class ItemSpec
+      extend T::Sig
+
+      IconValue = T.type_alias { T.nilable(T.any(String, Symbol, ViewComponent::Base, ViewComponent::Slot, ActiveSupport::SafeBuffer)) }
+      InputValue = T.type_alias do
+        T.nilable(T.any(
+          String,
+          Symbol,
+          T::Boolean,
+          Numeric,
+          ViewComponent::Base,
+          ViewComponent::Slot,
+          ActiveSupport::SafeBuffer,
+          Types::HtmlAttributes
+        ))
+      end
+      InputAttributes = T.type_alias { T::Hash[Symbol, InputValue] }
+
+      sig do
+        params(
+          icon: IconValue,
+          description: T.nilable(String),
+          tooltip: T.nilable(String),
+          href: T.nilable(String),
+          target: T.nilable(String),
+          type: Symbol,
+          danger: T::Boolean,
+          html_options: Types::HtmlAttributes
+        ).void
+      end
+      def initialize(icon:, description: nil, tooltip: nil, href: nil, target: nil, type: :default, danger: false, html_options: {})
+        @icon = T.let(icon, IconValue)
+        @description = T.let(description, T.nilable(String))
+        @tooltip = T.let(tooltip, T.nilable(String))
+        @href = T.let(href, T.nilable(String))
+        @target = T.let(target, T.nilable(String))
+        @type = T.let(type, Symbol)
+        @danger = T.let(danger, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+      end
+
+      sig { returns(IconValue) }
+      attr_reader :icon
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :description, :tooltip, :href, :target
+
+      sig { returns(Symbol) }
+      attr_reader :type
+
+      sig { returns(T::Boolean) }
+      attr_reader :danger
+
+      sig { returns(Types::HtmlAttributes) }
+      attr_reader :html_options
+
+      sig { params(items: T::Array[T.any(InputAttributes, HakumiComponents::FloatButton::ItemSpec)]).returns(T::Array[HakumiComponents::FloatButton::ItemSpec]) }
+      def self.coerce_all(items)
+        items.map { |item| coerce(item) }
+      end
+
+      sig { params(item: T.any(InputAttributes, HakumiComponents::FloatButton::ItemSpec)).returns(HakumiComponents::FloatButton::ItemSpec) }
+      def self.coerce(item)
+        return item if item.is_a?(HakumiComponents::FloatButton::ItemSpec)
+
+        new(
+          icon: coerce_icon(item[:icon]),
+          description: coerce_string(item[:description]),
+          tooltip: coerce_string(item[:tooltip]),
+          href: coerce_string(item[:href]),
+          target: coerce_string(item[:target]),
+          type: coerce_symbol(item[:type]) || :default,
+          danger: item[:danger] == true,
+          html_options: coerce_html_attributes(item[:html_options])
+        )
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: InputValue).returns(IconValue) }
+        def coerce_icon(value)
+          return value if value.is_a?(String)
+          return value if value.is_a?(Symbol)
+          return value if value.is_a?(ViewComponent::Base)
+          return value if value.is_a?(ViewComponent::Slot)
+
+          nil
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(String)) }
+        def coerce_string(value)
+          value.is_a?(String) ? value : nil
+        end
+
+        sig { params(value: InputValue).returns(T.nilable(Symbol)) }
+        def coerce_symbol(value)
+          value.is_a?(Symbol) ? value : nil
+        end
+
+        sig { params(value: InputValue).returns(Types::HtmlAttributes) }
+        def coerce_html_attributes(value)
+          value.is_a?(Hash) ? value : {}
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/float_button/position_config.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module FloatButton
+    class PositionConfig
+      extend T::Sig
+
+      PLACEMENTS = T.let({
+        bottom_right: { bottom: 24, right: 24 },
+        bottom_left: { bottom: 24, left: 24 },
+        top_right: { top: 24, right: 24 },
+        top_left: { top: 24, left: 24 }
+      }.freeze, T::Hash[Symbol, T::Hash[Symbol, Integer]])
+
+      OffsetValue = T.type_alias { T.nilable(T.any(Integer, String)) }
+      OffsetMap = T.type_alias { T::Hash[Symbol, OffsetValue] }
+
+      sig { params(floating: T::Boolean, placement: Symbol, offset: T.nilable(OffsetMap)).void }
+      def initialize(floating:, placement:, offset: nil)
+        @floating = T.let(floating, T::Boolean)
+        @placement = T.let(placement, Symbol)
+        @offset = T.let(offset, T.nilable(OffsetMap))
+        validate_placement!
+      end
+
+      sig { returns(T::Boolean) }
+      attr_reader :floating
+
+      sig { returns(Symbol) }
+      attr_reader :placement
+
+      sig { returns(T.nilable(String)) }
+      def style
+        return nil unless @floating
+
+        segments = T.let([ "position: fixed", "z-index: 1000" ], T::Array[String])
+        resolved_offset.each do |key, value|
+          next if value.nil?
+
+          segments << "#{key}: #{dimension(value)}"
+        end
+        segments.join("; ")
+      end
+
+      sig { returns(OffsetMap) }
+      def resolved_offset
+        base = T.let(PLACEMENTS.fetch(@placement).dup, OffsetMap)
+        extra = @offset || {}
+        base.merge(extra).compact
+      end
+
+      private
+
+      sig { params(value: T.any(Integer, String)).returns(String) }
+      def dimension(value)
+        value.is_a?(String) ? value : "#{value}px"
+      end
+
+      sig { void }
+      def validate_placement!
+        return if PLACEMENTS.key?(@placement)
+
+        raise ArgumentError, "placement must be one of #{PLACEMENTS.keys.inspect}, got #{@placement.inspect}"
+      end
+    end
+  end
+end