hakumi_components 0.1.17.pre → 0.1.19.pre

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

data/app/components/{hakumi → hakumi_components}/form/item/component.rb

@@ -1,25 +1,22 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Form
     module Item
-      # Hakumi Form Item component
-      # Wrapper component for form fields that handles labels, errors, and help text
-      # This is the central component that all form inputs should use or delegate to
-      #
-      # @example Basic usage
-      #   <%= render Hakumi::Form::Item::Component.new(label: "Email") do %>
-      #     <%= render Hakumi::Input::Component.new(name: "email", standalone: true) %>
-      #   <% end %>
-      #
-      # @example With error
-      #   <%= render Hakumi::Form::Item::Component.new(
-      #     label: "Email",
-      #     errors: ["can't be blank"]
-      #   ) do %>
-      #     <%= render Hakumi::Input::Component.new(name: "email", standalone: true) %>
-      #   <% end %>
-      class Component < Hakumi::BaseComponent
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            label: T.nilable(String),
+            caption: T.nilable(String),
+            errors: T.any(String, T::Array[String]),
+            required: T::Boolean,
+            field_id: T.nilable(String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           label: nil,
           caption: nil,
@@ -28,28 +25,31 @@ module Hakumi
           field_id: nil,
           **html_options
         )
-          @label = label
-          @caption = caption
-          @errors = Array(errors)
-          @required = required
-          @field_id = field_id
-          @html_options = html_options
+          @label = T.let(label, T.nilable(String))
+          @caption = T.let(caption, T.nilable(String))
+          @errors = T.let(Array(errors), T::Array[String])
+          @required = T.let(required, T::Boolean)
+          @field_id = T.let(field_id, T.nilable(String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def call
           content_tag(:div, wrapper_content, wrapper_attributes)
         end
 
         private
 
-        def has_error?
+        sig { returns(T::Boolean) }
+        def error?
           @errors.any?
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           classes = [ "hakumi-form-item" ]
-          classes << "hakumi-form-item-has-error" if has_error?
-          classes << "hakumi-form-item-with-help" if has_error? || @caption
+          classes << "hakumi-form-item-has-error" if error?
+          classes << "hakumi-form-item-with-help" if error? || @caption
 
           merge_attributes(
             { class: classes.join(" ") },
@@ -57,6 +57,7 @@ module Hakumi
           )
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def wrapper_content
           safe_join([
             label_content,
@@ -64,6 +65,7 @@ module Hakumi
           ].compact)
         end
 
+        sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
         def label_content
           return nil if @label.blank?
 
@@ -77,6 +79,7 @@ module Hakumi
           end
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def control_content
           content_tag(:div, class: "hakumi-form-item-control") do
             safe_join([
@@ -86,18 +89,21 @@ module Hakumi
           end
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def control_input_content
           content_tag(:div, content, class: "hakumi-form-item-control-input")
         end
 
+        sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
         def explain_content
-          return nil unless @caption || has_error?
+          return nil unless @caption || error?
 
           content_tag(:div, class: "hakumi-form-item-explain") do
-            has_error? ? error_content : caption_content
+            error? ? error_content : caption_content
           end
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def error_content
           content_tag(:div, @errors.first,
             class: "hakumi-form-item-explain-error",
@@ -105,6 +111,7 @@ module Hakumi
           )
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def caption_content
           content_tag(:div, @caption, class: "hakumi-form-item-extra")
         end