hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/skeleton/node/component.rb

@@ -1,39 +1,55 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Skeleton
     module Node
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            active: T::Boolean,
+            size: T.any(Integer, String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(active: false, size: 40, **html_options)
-          @active = active
-          @size = size
-          @html_options = html_options
+          @active = T.let(active, T::Boolean)
+          @size = T.let(size, T.any(Integer, String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_props!
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
         end
 
+        sig { returns(String) }
         def node_classes
           class_names("skeleton-node")
         end
 
+        sig { returns(T.nilable(String)) }
         def node_style
-          return nil unless @size
+          css = dimension_to_css(@size)
+          return nil unless css
 
-          "width: #{dimension_to_css(@size)}; height: #{dimension_to_css(@size)};"
+          "width: #{css}; height: #{css};"
         end
 
         private
 
+        sig { returns(String) }
         def wrapper_classes
-          class_names("skeleton", { element: true, active: @active }, @html_options[:class])
+          component_classes("skeleton", { element: true, active: @active }, @html_options)
         end
 
+        sig { void }
         def validate_props!
-          return if @size.nil? || @size.is_a?(Numeric) || @size.is_a?(String)
+          return if @size.is_a?(Numeric) || @size.is_a?(String)
 
           raise ArgumentError, "size must be a number or string"
         end

data/app/components/hakumi_components/skeleton/paragraph_config.rb

@@ -0,0 +1,92 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Skeleton
+    class ParagraphConfig
+      extend T::Sig
+
+      WidthValue = T.type_alias { T.any(Integer, String) }
+      WidthSource = T.type_alias { T.nilable(T.any(WidthValue, T::Array[WidthValue])) }
+      Input = T.type_alias { T.any(T::Boolean, Types::HtmlAttributes, HakumiComponents::Skeleton::ParagraphConfig) }
+
+      sig { params(rows: Integer, width_source: WidthSource).void }
+      def initialize(rows: 3, width_source: nil)
+        @rows = T.let(rows, Integer)
+        @width_source = T.let(width_source, WidthSource)
+        validate!
+      end
+
+      sig { returns(Integer) }
+      attr_reader :rows
+
+      sig { params(default_rows: Integer).returns(T::Array[WidthValue]) }
+      def row_widths(default_rows)
+        rows = @rows.positive? ? @rows : default_rows
+        resolved = case @width_source
+        when Array
+          @width_source
+        when nil
+          default_widths(rows)
+        else
+          Array.new(rows, @width_source)
+        end
+
+        normalized = resolved.first(rows)
+        normalized.fill("100%", normalized.length...rows)
+        normalized
+      end
+
+      sig { params(value: Input).returns(T.nilable(HakumiComponents::Skeleton::ParagraphConfig)) }
+      def self.coerce(value)
+        return nil if value == false
+        return new if value == true
+        return value if value.is_a?(HakumiComponents::Skeleton::ParagraphConfig)
+
+        rows = parse_rows(value[:rows])
+        widths = parse_width_source(value[:widths], value[:width])
+        new(rows: rows || 3, width_source: widths)
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Integer)) }
+        def parse_rows(value)
+          return value if value.is_a?(Integer)
+          return value.to_i if value.is_a?(String) && value.present?
+
+          nil
+        end
+
+        sig { params(widths: Types::HtmlAttributeValue, width: Types::HtmlAttributeValue).returns(WidthSource) }
+        def parse_width_source(widths, width)
+          if widths.is_a?(Array)
+            return widths.compact
+          end
+          return width if width.is_a?(Integer) || width.is_a?(String)
+
+          nil
+        end
+      end
+
+      private
+
+      sig { params(rows: Integer).returns(T::Array[WidthValue]) }
+      def default_widths(rows)
+        widths = T.let(Array.new(rows, "100%"), T::Array[WidthValue])
+        widths[-1] = "61%" if rows > 1
+        widths
+      end
+
+      sig { void }
+      def validate!
+        return if @rows >= 1
+
+        raise ArgumentError, "paragraph rows must be a positive integer"
+      end
+    end
+  end
+end

data/app/components/hakumi_components/skeleton/title_config.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Skeleton
+    class TitleConfig
+      extend T::Sig
+
+      WidthValue = T.type_alias { T.any(Integer, String) }
+      Input = T.type_alias { T.any(T::Boolean, Types::HtmlAttributes, HakumiComponents::Skeleton::TitleConfig) }
+
+      sig { params(width: T.nilable(WidthValue)).void }
+      def initialize(width: nil)
+        @width = T.let(width, T.nilable(WidthValue))
+      end
+
+      sig { returns(T.nilable(WidthValue)) }
+      attr_reader :width
+
+      sig { params(value: Input).returns(T.nilable(HakumiComponents::Skeleton::TitleConfig)) }
+      def self.coerce(value)
+        return nil if value == false
+        return new if value == true
+        return value if value.is_a?(HakumiComponents::Skeleton::TitleConfig)
+
+        width = value[:width]
+        new(width: width.is_a?(Integer) || width.is_a?(String) ? width : nil)
+      end
+    end
+  end
+end

data/app/components/hakumi_components/slider/component.html.erb

@@ -7,12 +7,12 @@
       <div
         class="hakumi-slider-handle"
         role="slider"
-        tabindex="<%= @disabled ? -1 : 0 %>"
+        tabindex="<%= slider_disabled? ? -1 : 0 %>"
         data-hakumi--slider-target="handle"
         data-index="<%= index %>"
-        aria-disabled="<%= @disabled %>"
-        aria-valuemin="<%= @min %>"
-        aria-valuemax="<%= @max %>"
+        aria-disabled="<%= slider_disabled? %>"
+        aria-valuemin="<%= slider_min %>"
+        aria-valuemax="<%= slider_max %>"
       >
         <span class="hakumi-slider-tooltip" data-hakumi--slider-target="tooltip"></span>
       </div>
@@ -20,16 +20,16 @@
 
     <% if marks? %>
       <div class="hakumi-slider-marks" data-hakumi--slider-target="marks">
-        <% @marks.each do |mark| %>
-          <span class="hakumi-slider-mark" style="<%= mark_style(mark[:value]) %>">
+        <% slider_marks.each do |mark| %>
+          <span class="hakumi-slider-mark" style="<%= mark_style(mark.value) %>">
             <span class="hakumi-slider-mark-dot"></span>
-            <span class="hakumi-slider-mark-label"><%= mark[:label] %></span>
+            <span class="hakumi-slider-mark-label"><%= mark.label %></span>
           </span>
         <% end %>
       </div>
     <% end %>
 
-    <% if @dots %>
+    <% if slider_dots? %>
       <div class="hakumi-slider-dots" data-hakumi--slider-target="dots">
         <% dot_values.each do |value| %>
           <span class="hakumi-slider-dot" style="<%= mark_style(value) %>"></span>
@@ -42,15 +42,15 @@
         type: "hidden",
         name: input_name,
         id: input_id_for(index),
-        value: @range ? Array(@value || @default_value)[index] : (@value || @default_value),
-        disabled: @disabled ? true : nil,
+        value: current_input_value(index),
+        disabled: slider_disabled? ? true : nil,
         data: { "hakumi--slider-target": "input" }
       ) %>
     <% end %>
   <% end %>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= slider_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>

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

@@ -1,12 +1,48 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Slider
-    # Hakumi Slider component
-    # Supports single and range sliders with marks, dots, and vertical layout.
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
       include HakumiComponents::Concerns::FormField
 
+      MarkScalar = T.type_alias { T.nilable(Types::ValidationPrimitive) }
+      MarkHash = T.type_alias { T::Hash[Types::HtmlKey, MarkScalar] }
+      MarkMap = T.type_alias { T::Hash[Types::ValidationPrimitive, Types::ValidationPrimitive] }
+      MarkEntry = T.type_alias { T.any(HakumiComponents::Slider::Mark, MarkHash, Types::ValidationPrimitive) }
+      NumericInput = T.type_alias { T.any(Numeric, String) }
+      MarksInput = T.type_alias do
+        T.nilable(T.any(MarkMap, T::Array[MarkEntry]))
+      end
+
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          default_value: Types::FormFieldValue,
+          min: NumericInput,
+          max: NumericInput,
+          step: NumericInput,
+          range: T::Boolean,
+          vertical: T::Boolean,
+          marks: MarksInput,
+          dots: T::Boolean,
+          tooltip_visible: T.nilable(T::Boolean),
+          keyboard: T::Boolean,
+          disabled: T::Boolean,
+          allow_cross: T::Boolean,
+          handle_min: Types::FormFieldValue,
+          handle_max: Types::FormFieldValue,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name: nil,
         label: nil,
@@ -29,34 +65,48 @@ module HakumiComponents
         standalone: true,
         required: false,
         errors: [],
-        **html_attrs
+        **html_options
       )
-        @name = name || generate_id("slider")
-        @label = label
-        @caption = caption
-        @value = value
-        @default_value = default_value
-        @min = min
-        @max = max
-        @step = step
-        @range = cast_boolean(range)
-        @vertical = cast_boolean(vertical)
-        @marks = normalize_marks(marks)
-        @dots = cast_boolean(dots)
-        @tooltip_visible = tooltip_visible
-        @keyboard = cast_boolean(keyboard)
-        @disabled = cast_boolean(disabled)
-        @allow_cross = cast_boolean(allow_cross)
-        @handle_min = handle_min
-        @handle_max = handle_max
-        @standalone = cast_boolean(standalone)
-        @required = cast_boolean(required)
-        @errors = Array(errors)
-        @html_attrs = html_attrs
+        validate_numeric_like!(min, "min")
+        validate_numeric_like!(max, "max")
+        validate_numeric_like!(step, "step")
+
+        @name = T.let(name || generate_id("slider"), Types::FormFieldName)
+        @label = T.let(label, T.nilable(String))
+        @caption = T.let(caption, T.nilable(String))
+        @value = T.let(value, Types::FormFieldValue)
+        @default_value = T.let(default_value, Types::FormFieldValue)
+        @min = T.let(min.to_s, String)
+        @max = T.let(max.to_s, String)
+        @step = T.let(step.to_s, String)
+        @range = T.let(cast_boolean(range) ? true : false, T::Boolean)
+        @vertical = T.let(cast_boolean(vertical) ? true : false, T::Boolean)
+        @marks = T.let(normalize_marks(marks), T::Array[HakumiComponents::Slider::Mark])
+        @dots = T.let(cast_boolean(dots) ? true : false, T::Boolean)
+        @tooltip_visible = T.let(cast_boolean(tooltip_visible), T.nilable(T::Boolean))
+        @keyboard = T.let(cast_boolean(keyboard) != false, T::Boolean)
+        @disabled = T.let(cast_boolean(disabled) ? true : false, T::Boolean)
+        @allow_cross = T.let(cast_boolean(allow_cross) != false, T::Boolean)
+        @handle_min = T.let(handle_min, Types::FormFieldValue)
+        @handle_max = T.let(handle_max, Types::FormFieldValue)
+        @standalone = T.let(cast_boolean(standalone) ? true : false, T::Boolean)
+        @required = T.let(cast_boolean(required) ? true : false, T::Boolean)
+        @errors = T.let(Array(errors), Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_form_field_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options
+        )
 
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           {
@@ -79,33 +129,63 @@ module HakumiComponents
             }.compact
           },
           {
-            id: @html_attrs[:id],
-            data: @html_attrs[:data]
+            id: @html_options[:id],
+            data: @html_options[:data]
           }.compact
         )
       end
 
+      sig { returns(Types::FormFieldName) }
       def input_name
-        return @name unless @range
-        return @name if @name.to_s.end_with?("[]")
+        return form_field_name unless @range
+        return form_field_name if form_field_name.to_s.end_with?("[]")
 
-        "#{@name}[]"
+        "#{form_field_name}[]"
       end
 
+      sig { params(index: Integer).returns(String) }
       def input_id_for(index)
-        return input_id unless @range
+        return input_id.to_s unless @range
 
         "#{input_id}_#{index}"
       end
 
+      sig { returns(Integer) }
       def handle_count
         @range ? 2 : 1
       end
 
+      sig { returns(T::Boolean) }
       def marks?
         @marks.any?
       end
 
+      sig { returns(T::Array[HakumiComponents::Slider::Mark]) }
+      def slider_marks
+        @marks
+      end
+
+      sig { returns(T::Boolean) }
+      def slider_dots?
+        @dots
+      end
+
+      sig { returns(T::Boolean) }
+      def slider_disabled?
+        @disabled
+      end
+
+      sig { returns(String) }
+      def slider_min
+        @min
+      end
+
+      sig { returns(String) }
+      def slider_max
+        @max
+      end
+
+      sig { params(value: String).returns(String) }
       def mark_style(value)
         percent = position_percent(value)
         if @vertical
@@ -115,6 +195,7 @@ module HakumiComponents
         end
       end
 
+      sig { returns(T::Array[String]) }
       def dot_values
         return [] unless @dots
 
@@ -123,32 +204,39 @@ module HakumiComponents
         step = @step.to_f
         return [] if step <= 0
 
-        values = []
+        values = T.let([], T::Array[String])
         current = min
         while current <= max + (step / 1000.0)
-          values << current
+          values << current.to_s
           current += step
         end
         values
       end
 
+      sig { params(index: Integer).returns(T.nilable(String)) }
+      def current_input_value(index = 0)
+        values = normalized_input_values
+        return values.first unless @range
+
+        values[index]
+      end
+
       private
 
+      sig { void }
       def validate_props!
-        validate_numeric_like!(@min, "min")
-        validate_numeric_like!(@max, "max")
-        validate_numeric_like!(@step, "step")
-
         validate_range_values!(@value, "value") if @value
         validate_range_values!(@default_value, "default_value") if @default_value
       end
 
+      sig { params(value: NumericInput, name: String).void }
       def validate_numeric_like!(value, name)
         return if value.is_a?(Numeric) || value.is_a?(String)
 
         raise ArgumentError, "#{name} must be a number or string"
       end
 
+      sig { params(value: Types::FormFieldValue, name: String).void }
       def validate_range_values!(value, name)
         if @range
           unless value.is_a?(Array) && value.size == 2
@@ -159,6 +247,7 @@ module HakumiComponents
         end
       end
 
+      sig { returns(String) }
       def component_html_class
         class_names(
           "slider",
@@ -170,59 +259,89 @@ module HakumiComponents
             "with-dots": @dots,
             "tooltip-visible": tooltip_visible_class?
           },
-          @html_attrs[:wrapper_class]
+          [ wrapper_class_name ]
         )
       end
 
+      sig { returns(T::Boolean) }
       def tooltip_visible_class?
         @tooltip_visible == true
       end
 
+      sig { returns(T.nilable(T::Boolean)) }
       def tooltip_visible_value
-        return nil if @tooltip_visible.nil?
-
-        cast_boolean(@tooltip_visible)
+        @tooltip_visible
       end
 
+      sig { params(value: Types::FormFieldValue).returns(T.nilable(String)) }
       def data_value(value)
         return nil if value.nil?
 
         Array(value).to_json
       end
 
+      sig { params(value: Types::FormFieldValue).returns(T.nilable(String)) }
       def handle_bounds_value(value)
         return nil if value.nil?
 
         Array(value).to_json
       end
 
+      sig { params(marks: MarksInput).returns(T::Array[HakumiComponents::Slider::Mark]) }
       def normalize_marks(marks)
         return [] if marks.nil?
 
         entries = if marks.is_a?(Hash)
-                    marks.map { |value, label| { value: value, label: label } }
+          marks.map { |value, label| HakumiComponents::Slider::Mark.new(value: value.to_s, label: label.to_s) }
         else
-                    Array(marks).map do |mark|
-                      if mark.is_a?(Hash)
-                        value = mark[:value] || mark["value"]
-                        label = mark[:label] || mark["label"] || value
-                        { value: value, label: label }
-                      else
-                        { value: mark, label: mark }
-                      end
-                    end
+          Array(marks).filter_map do |mark|
+            next mark if mark.is_a?(HakumiComponents::Slider::Mark)
+
+            if mark.is_a?(Hash)
+              value = mark[:value] || mark["value"]
+              label = mark[:label] || mark["label"] || value
+              next nil if value.nil?
+
+              HakumiComponents::Slider::Mark.new(value: value.to_s, label: label.to_s)
+            else
+              HakumiComponents::Slider::Mark.new(value: mark.to_s, label: mark.to_s)
+            end
+          end
         end
 
-        entries.compact.select { |entry| entry[:value].present? }.sort_by { |entry| entry[:value].to_f }
+        entries.sort_by(&:numeric_value)
       end
 
+      sig { params(value: String).returns(Float) }
       def position_percent(value)
         min = @min.to_f
         max = @max.to_f
-        return 0 if max == min
+        return 0.0 if max == min
 
         ((value.to_f - min) / (max - min) * 100).clamp(0, 100)
       end
+
+      sig { returns(T::Array[String]) }
+      def normalized_input_values
+        value = @value.nil? ? @default_value : @value
+        return [] if value.nil?
+
+        if value.is_a?(Array)
+          value.filter_map do |item|
+            next if item.nil?
+
+            item.to_s
+          end
+        else
+          [ value.to_s ]
+        end
+      end
+
+      sig { returns(T.nilable(String)) }
+      def wrapper_class_name
+        css_class = @html_options[:wrapper_class]
+        css_class.is_a?(String) ? css_class : nil
+      end
     end
   end
 end

data/app/components/hakumi_components/slider/mark.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Slider
+    class Mark
+      extend T::Sig
+
+      sig { params(value: String, label: String).void }
+      def initialize(value:, label:)
+        @value = value
+        @label = label
+      end
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { returns(Float) }
+      def numeric_value
+        @value.to_f
+      end
+    end
+  end
+end

data/app/components/hakumi_components/space/compact/component.html.erb

@@ -1,3 +1 @@
-<div <%= tag.attributes(html_attributes) %>>
-  <%= content %>
-</div>
+<%= content_tag :div, content, wrapper_attributes %>