hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,17 +1,36 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Tooltip
-    class Component < HakumiComponents::BaseComponent
-      TRIGGERS = %i[hover focus click].freeze
-      PLACEMENTS = %i[
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+      Trigger = T.type_alias { Types::HtmlKey }
+      Placement = T.type_alias { Types::HtmlKey }
+      Color = T.type_alias { Types::HtmlKey }
+
+      TRIGGERS = T.let(%i[hover focus click].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let(%i[
         top top_left top_right
         bottom bottom_left bottom_right
         left left_top left_bottom
         right right_top right_bottom
-      ].freeze
-      COLORS = %i[default pink red yellow orange cyan green blue purple geekblue magenta volcano gold lime].freeze
-
+      ].freeze, T::Array[Symbol])
+      COLORS = T.let(%i[default pink red yellow orange cyan green blue purple geekblue magenta volcano gold lime].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          title: HakumiComponents::Types::Renderable,
+          placement: Placement,
+          trigger: Trigger,
+          arrow: T::Boolean,
+          color: Color,
+          open: T.nilable(T::Boolean),
+          fresh: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         title: nil,
         placement: :top,
@@ -22,59 +41,48 @@ module HakumiComponents
         fresh: false,
         **html_options
       )
-        @title = title
-        @placement = placement
-        @trigger = trigger
-        @arrow = arrow
-        @color = color
-        @open = open
-        @fresh = fresh
-        @html_options = html_options
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @placement = T.let(placement.to_sym, Symbol)
+        @trigger = T.let(trigger.to_sym, Symbol)
+        @arrow = T.let(cast_boolean(arrow) != false, T::Boolean)
+        @color = T.let(color.is_a?(String) ? color : color.to_sym, Color)
+        @open = T.let(open, T.nilable(T::Boolean))
+        @fresh = T.let(cast_boolean(fresh) ? true : false, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
-      attr_reader :title, :placement, :trigger, :arrow, :color, :open, :fresh
-
-      def wrapper_classes
-        classes = [ "hakumi-tooltip-wrapper" ]
-        classes << "hakumi-tooltip-open" if @open == true
-        classes.join(" ")
-      end
+      sig { returns(HakumiComponents::Types::Renderable) }
+      attr_reader :title
 
-      def tooltip_classes
-        classes = [ "hakumi-tooltip" ]
-        classes << placement_class
-        classes << color_class if preset_color?
-        classes.join(" ")
-      end
-
-      def placement_class
-        "hakumi-tooltip-placement-#{@placement.to_s.dasherize}"
-      end
+      sig { returns(Symbol) }
+      attr_reader :placement, :trigger
 
-      def color_class
-        "hakumi-tooltip-#{@color}" if preset_color?
-      end
+      sig { returns(T::Boolean) }
+      attr_reader :arrow, :fresh
 
-      def preset_color?
-        @color.is_a?(Symbol) && @color != :default && COLORS.include?(@color)
-      end
+      sig { returns(Color) }
+      attr_reader :color
 
-      def custom_color?
-        @color.is_a?(String)
-      end
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :open
 
-      def custom_color_style
-        return unless custom_color?
-        "background-color: #{@color};"
+      sig { returns(String) }
+      def wrapper_classes
+        extras = T.let([], T::Array[T.nilable(String)])
+        extras << "hakumi-tooltip-open" if @open == true
+        extras.concat(Array(html_classes(@html_options)).compact)
+        class_names("tooltip-wrapper", {}, extras)
       end
 
-      def stimulus_controller
-        "hakumi--tooltip"
+      sig { returns(String) }
+      def tooltip_classes
+        class_names("tooltip", {}, [ placement_class, (color_class if preset_color?) ])
       end
 
-      def stimulus_values
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def wrapper_attributes
         values = {
           placement: @placement.to_s.dasherize,
           trigger: @trigger.to_s,
@@ -83,39 +91,56 @@ module HakumiComponents
         }
         values[:open] = @open unless @open.nil?
         values[:color] = @color.to_s if custom_color?
-        values
+
+        merge_attributes(
+          { class: wrapper_classes, data: stimulus_attrs(stimulus_controller, values) },
+          @html_options
+        )
       end
 
-      def wrapper_attributes
-        base_attrs = {
-          class: wrapper_classes,
-          data: {
-            controller: stimulus_controller
-          }.merge(stimulus_data_attributes)
-        }
-        merge_attributes(base_attrs, @html_options)
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def tooltip_text
+        render_value(@title)
       end
 
-      def stimulus_data_attributes
-        stimulus_values.transform_keys { |k| "#{stimulus_controller}-#{k.to_s.dasherize}-value" }
+      sig { returns(T::Boolean) }
+      def tooltip_content?
+        value_present?(@title)
       end
 
-      def tooltip_text
-        @title
+      private
+
+      sig { returns(String) }
+      def placement_class
+        "hakumi-tooltip-placement-#{@placement.to_s.dasherize}"
       end
 
-      def has_tooltip_content?
-        @title.present?
+      sig { returns(T.nilable(String)) }
+      def color_class
+        "hakumi-tooltip-#{@color}" if preset_color?
       end
 
-      private
+      sig { returns(T::Boolean) }
+      def preset_color?
+        @color.is_a?(Symbol) && @color != :default && COLORS.include?(@color)
+      end
+
+      sig { returns(T::Boolean) }
+      def custom_color?
+        @color.is_a?(String)
+      end
+
+      sig { returns(String) }
+      def stimulus_controller
+        "hakumi--tooltip"
+      end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:placement, PLACEMENTS)
         validate_inclusion!(:trigger, TRIGGERS)
-        # Only validate color if it's a symbol (preset), strings are custom colors
         validate_inclusion!(:color, COLORS) if @color.is_a?(Symbol)
       end
-    end
+      end
   end
 end

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

@@ -1,46 +1,69 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Tour
     class Component < HakumiComponents::BaseComponent
-      SIZES = %w[small default large].freeze
-      TYPES = %w[default primary].freeze
-      PLACEMENTS = %w[
+      extend T::Sig
+
+      Size = T.type_alias { T.any(Symbol, String) }
+      Type = T.type_alias { T.any(Symbol, String) }
+      Placement = T.type_alias { T.any(Symbol, String) }
+
+      TYPES = T.let(%i[default primary].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let(%i[
         top top_left top_right
         bottom bottom_left bottom_right
         left left_top left_bottom
         right right_top right_bottom
-      ].freeze
-
+      ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          steps: T::Array[HakumiComponents::Tour::Step::Source],
+          open: T::Boolean,
+          current: Integer,
+          size: Size,
+          type: Type,
+          placement: Placement,
+          mask: T::Boolean,
+          mask_closable: T::Boolean,
+          closable: T::Boolean,
+          show_progress: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         steps: [],
         open: false,
         current: 0,
-        size: "default",
-        type: "default",
-        placement: "bottom",
+        size: :default,
+        type: :default,
+        placement: :bottom,
         mask: true,
         mask_closable: true,
         closable: true,
         show_progress: true,
-        **html_attrs
+        **html_options
       )
-        @steps = steps
-        @open = open
-        @current = current
-        @size = size
-        @type = type
-        @placement = placement
-        @mask = mask
-        @mask_closable = mask_closable
-        @closable = closable
-        @show_progress = show_progress
-        @html_attrs = html_attrs
-        @component_id = @html_attrs[:id] || generate_id("hakumi-tour", length: 6)
+        @steps = T.let(steps, T::Array[HakumiComponents::Tour::Step::Source])
+        @open = T.let(open, T::Boolean)
+        @current = T.let(current, Integer)
+        @size = T.let(size.to_sym, Symbol)
+        @type = T.let(type.to_sym, Symbol)
+        @placement = T.let(placement.to_sym, Symbol)
+        @mask = T.let(mask, T::Boolean)
+        @mask_closable = T.let(mask_closable, T::Boolean)
+        @closable = T.let(closable, T::Boolean)
+        @show_progress = T.let(show_progress, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+        raw_id = @html_options[:id]
+        @component_id = T.let(raw_id.nil? ? generate_id("hakumi-tour", length: 6) : raw_id.to_s, String)
 
         validate_props!
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def component_html_attributes
         merge_attributes(
           {
@@ -51,33 +74,38 @@ module HakumiComponents
               hakumi__tour_open_value: @open,
               hakumi__tour_current_value: @current,
               hakumi__tour_steps_value: steps_json,
-              hakumi__tour_placement_value: normalized_placement(@placement),
+              hakumi__tour_placement_value: @placement.to_s.tr("_", "-"),
               hakumi__tour_mask_value: @mask,
               hakumi__tour_mask_closable_value: @mask_closable,
               hakumi__tour_closable_value: @closable,
               hakumi__tour_show_progress_value: @show_progress
             }
           },
-          @html_attrs
+          @html_options
         )
       end
 
+      sig { returns(String) }
       def title_id
         "#{@component_id}-title"
       end
 
+      sig { returns(String) }
       def body_id
         "#{@component_id}-body"
       end
 
+      sig { returns(String) }
       def current_step_title
-        current_step[:title]
+        current_step.title
       end
 
+      sig { returns(String) }
       def current_step_body
-        current_step[:body]
+        current_step.body
       end
 
+      sig { returns(T.nilable(String)) }
       def progress_label
         return nil unless @show_progress
         return "0 / 0" if normalized_steps.empty?
@@ -85,24 +113,28 @@ module HakumiComponents
         "#{current_index + 1} / #{normalized_steps.length}"
       end
 
+      sig { returns(T::Boolean) }
       def first_step?
         current_index.zero?
       end
 
+      sig { returns(T::Boolean) }
       def last_step?
         normalized_steps.any? && current_index == normalized_steps.length - 1
       end
 
       private
 
+      sig { returns(String) }
       def component_html_class
         modifiers = { "open" => @open }
-        modifiers[@size] = true if @size != "default"
-        modifiers[@type] = true if @type != "default"
+        modifiers[@size] = true if @size != :default
+        modifiers[@type] = true if @type != :default
 
-        class_names("tour", modifiers, [ @html_attrs[:class] ])
+        class_names("tour", modifiers, html_classes(@html_options))
       end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:type, TYPES)
@@ -110,49 +142,42 @@ module HakumiComponents
         validate_steps!
       end
 
+      sig { void }
       def validate_steps!
-        Array(@steps).each_with_index do |step, index|
-          step_hash = step.respond_to?(:to_h) ? step.to_h : {}
-          placement = step_hash[:placement] || step_hash["placement"]
-          next if placement.nil?
-          next if PLACEMENTS.include?(placement.to_s)
+        @steps.each_with_index do |step, index|
+          placement = HakumiComponents::Tour::Step.from_input(step, default_placement: @placement).placement
+          next if PLACEMENTS.include?(placement)
 
           raise ArgumentError, "steps[#{index}] placement must be one of #{PLACEMENTS.inspect}, got #{placement.inspect}"
         end
       end
 
+      sig { returns(T::Array[HakumiComponents::Tour::Step]) }
       def normalized_steps
-        @normalized_steps ||= Array(@steps).map do |step|
-          step_hash = step.respond_to?(:to_h) ? step.to_h : {}
-          step_hash = step_hash.transform_keys { |key| key.to_sym }
-
-          {
-            title: step_hash[:title].to_s,
-            body: (step_hash[:body] || step_hash[:description]).to_s,
-            target: step_hash[:target].presence,
-            placement: normalized_placement(step_hash[:placement] || @placement)
-          }
+        @normalized_steps = T.let(@normalized_steps, T.nilable(T::Array[HakumiComponents::Tour::Step])) if instance_variable_defined?(:@normalized_steps)
+        @normalized_steps ||= @steps.map do |step|
+          HakumiComponents::Tour::Step.from_input(step, default_placement: @placement)
         end
       end
 
+      sig { returns(String) }
       def steps_json
-        normalized_steps.to_json
+        normalized_steps.map(&:to_h).to_json
       end
 
+      sig { returns(HakumiComponents::Tour::Step) }
       def current_step
-        normalized_steps[current_index] || { title: "", body: "" }
+        normalized_steps[current_index] || HakumiComponents::Tour::Step.new(title: "", body: "", placement: @placement)
       end
 
+      sig { returns(Integer) }
       def current_index
         return 0 if normalized_steps.empty?
+
         index = @current.to_i
         index = 0 if index.negative?
         index >= normalized_steps.length ? normalized_steps.length - 1 : index
       end
-
-      def normalized_placement(value)
-        value.to_s.tr("_", "-")
-      end
     end
   end
 end

data/app/components/hakumi_components/tour/step.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tour
+    class Step
+      extend T::Sig
+
+      InputValue = T.type_alias { T.nilable(Types::StringOrSymbol) }
+      InputHash = T.type_alias { T.any(T::Hash[Symbol, InputValue], T::Hash[String, InputValue]) }
+      Source = T.type_alias { T.any(Step, InputHash) }
+
+      sig do
+        params(
+          title: String,
+          body: String,
+          placement: Symbol,
+          target: T.nilable(String)
+        ).void
+      end
+      def initialize(title:, body:, placement:, target: nil)
+        @title = title
+        @body = body
+        @target = target
+        @placement = placement
+      end
+
+      sig { returns(String) }
+      attr_reader :title
+
+      sig { returns(String) }
+      attr_reader :body
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :target
+
+      sig { returns(Symbol) }
+      attr_reader :placement
+
+      sig { params(step: Source, default_placement: Symbol).returns(Step) }
+      def self.from_input(step, default_placement:)
+        return step if step.is_a?(Step)
+
+        title = read_input(step, :title).to_s
+        body = read_input(step, :body, :description).to_s
+        target = read_input(step, :target)&.to_s
+        placement = (read_input(step, :placement) || default_placement).to_s.to_sym
+
+        Step.new(
+          title: title,
+          body: body,
+          placement: placement,
+          target: target
+        )
+      end
+
+      sig { returns(T::Hash[Symbol, T.nilable(String)]) }
+      def to_h
+        {
+          title: @title,
+          body: @body,
+          target: @target,
+          placement: @placement.to_s.tr("_", "-")
+        }
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(input: InputHash, keys: T.any(Symbol, String)).returns(InputValue) }
+        def read_input(input, *keys)
+          keys.each do |key|
+            return input[key] if input.key?(key)
+
+            string_key = key.to_s
+            return input[string_key] if input.key?(string_key)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/transfer/coercion.rb

@@ -0,0 +1,66 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Transfer
+    module Coercion
+      extend T::Sig
+      extend self
+
+      ItemValue = T.type_alias { HakumiComponents::Types::FormFieldScalar }
+      TitleValue = T.type_alias { T.any(String, Symbol, Numeric) }
+      ItemHash = T.type_alias { T::Hash[HakumiComponents::Types::HtmlKey, ItemValue] }
+      ItemInput = T.type_alias { T.any(HakumiComponents::Transfer::Item, ItemHash, HakumiComponents::Types::FormFieldScalar) }
+
+      sig { params(items: T::Array[ItemInput], disabled: T::Boolean).returns(T::Array[HakumiComponents::Transfer::Item]) }
+      def items(items, disabled:)
+        items.map.with_index do |item, index|
+          normalize_item(item, index: index, disabled: disabled)
+        end
+      end
+
+      private
+
+      sig { params(item: ItemInput, index: Integer, disabled: T::Boolean).returns(HakumiComponents::Transfer::Item) }
+      def normalize_item(item, index:, disabled:)
+        return item if item.is_a?(HakumiComponents::Transfer::Item)
+
+        if item.is_a?(Hash)
+          key = item[:key] || item["key"] || index
+          raw_title = item[:title] || item["title"] || key
+          title = coerce_title(raw_title)
+          return HakumiComponents::Transfer::Item.new(
+            key: key.to_s,
+            title: title,
+            description: normalize_string(item[:description] || item["description"]),
+            disabled: disabled || (item[:disabled] == true) || (item["disabled"] == true),
+            class_name: normalize_string(item[:class_name] || item["class_name"])
+          )
+        end
+
+        HakumiComponents::Transfer::Item.new(
+          key: item.to_s,
+          title: coerce_title(item),
+          description: nil,
+          disabled: disabled,
+          class_name: nil
+        )
+      end
+
+      sig { params(value: ItemValue).returns(TitleValue) }
+      def coerce_title(value)
+        return value if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric)
+
+        value.to_s
+      end
+
+      sig { params(value: ItemValue).returns(T.nilable(String)) }
+      def normalize_string(value)
+        return nil if value.nil?
+
+        normalized = value.to_s.strip
+        normalized.empty? ? nil : normalized
+      end
+    end
+  end
+end