hakumi_components 0.1.17.pre → 0.1.19.pre

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 → 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

@@ -0,0 +1,347 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Slider
+    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,
+        caption: nil,
+        value: nil,
+        default_value: nil,
+        min: 0,
+        max: 100,
+        step: 1,
+        range: false,
+        vertical: false,
+        marks: nil,
+        dots: false,
+        tooltip_visible: nil,
+        keyboard: true,
+        disabled: false,
+        allow_cross: true,
+        handle_min: nil,
+        handle_max: nil,
+        standalone: true,
+        required: false,
+        errors: [],
+        **html_options
+      )
+        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(
+          {
+            class: component_html_class,
+            data: {
+              controller: "hakumi--slider",
+              "hakumi--slider-min-value": @min,
+              "hakumi--slider-max-value": @max,
+              "hakumi--slider-step-value": @step,
+              "hakumi--slider-range-value": @range,
+              "hakumi--slider-vertical-value": @vertical,
+              "hakumi--slider-disabled-value": @disabled,
+              "hakumi--slider-keyboard-value": @keyboard,
+              "hakumi--slider-allow-cross-value": @allow_cross,
+              "hakumi--slider-handle-min-value": handle_bounds_value(@handle_min),
+              "hakumi--slider-handle-max-value": handle_bounds_value(@handle_max),
+              "hakumi--slider-tooltip-visible-value": tooltip_visible_value,
+              "hakumi--slider-value-value": data_value(@value),
+              "hakumi--slider-default-value-value": data_value(@default_value)
+            }.compact
+          },
+          {
+            id: @html_options[:id],
+            data: @html_options[:data]
+          }.compact
+        )
+      end
+
+      sig { returns(Types::FormFieldName) }
+      def input_name
+        return form_field_name unless @range
+        return form_field_name if form_field_name.to_s.end_with?("[]")
+
+        "#{form_field_name}[]"
+      end
+
+      sig { params(index: Integer).returns(String) }
+      def input_id_for(index)
+        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
+          "bottom: #{percent}%"
+        else
+          "left: #{percent}%"
+        end
+      end
+
+      sig { returns(T::Array[String]) }
+      def dot_values
+        return [] unless @dots
+
+        min = @min.to_f
+        max = @max.to_f
+        step = @step.to_f
+        return [] if step <= 0
+
+        values = T.let([], T::Array[String])
+        current = min
+        while current <= max + (step / 1000.0)
+          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_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
+            raise ArgumentError, "#{name} must be an array of two values when range is true"
+          end
+        elsif value.is_a?(Array)
+          raise ArgumentError, "#{name} must be a single value when range is false"
+        end
+      end
+
+      sig { returns(String) }
+      def component_html_class
+        class_names(
+          "slider",
+          {
+            range: @range,
+            vertical: @vertical,
+            disabled: @disabled,
+            "with-marks": marks?,
+            "with-dots": @dots,
+            "tooltip-visible": tooltip_visible_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
+        @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| HakumiComponents::Slider::Mark.new(value: value.to_s, label: label.to_s) }
+        else
+          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.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.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

@@ -0,0 +1 @@
+<%= content_tag :div, content, wrapper_attributes %>

data/app/components/hakumi_components/space/compact/component.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Space
+    module Compact
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+        DIRECTIONS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            direction: T.any(Symbol, String),
+            block: T::Boolean,
+            html_options: HakumiComponents::Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(direction: :horizontal, block: false, **html_options)
+          @direction = T.let(direction.to_sym, Symbol)
+          @block = T.let(block, T::Boolean)
+          @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+          validate_props!
+        end
+
+        private
+
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:direction, DIRECTIONS)
+        end
+
+        sig { returns(String) }
+        def wrapper_classes
+          class_names(
+            "space-compact",
+            { @direction => true, block: @block },
+            html_classes(@html_options)
+          )
+        end
+
+        sig { returns(HakumiComponents::Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes(
+            { class: wrapper_classes },
+            @html_options.except(:class)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-<div <%= tag.attributes(html_attributes) %>>
+<div <%= tag.attributes(wrapper_attributes) %>>
   <% if items? %>
     <% items.each_with_index do |item, index| %>
       <%= item %>