hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/timeline/item/component.rb

@@ -0,0 +1,198 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Timeline
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        ColorValue = T.type_alias { Types::HtmlKey }
+        ContentBlock = T.type_alias { T.nilable(T.proc.returns(Types::RenderedContent)) }
+
+        COLORS = T.let(
+          {
+            blue: "var(--color-primary)",
+            red: "var(--color-error)",
+            green: "var(--color-success)",
+            gray: "var(--color-text-secondary)"
+          }.freeze,
+          T::Hash[Symbol, String]
+        )
+        POSITIONS = T.let(%i[left right].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            title: Types::Renderable,
+            body: Types::Renderable,
+            color: ColorValue,
+            dot: Types::Renderable,
+            position: T.nilable(Symbol),
+            loading: T::Boolean,
+            parent: T.nilable(HakumiComponents::Timeline::Component),
+            pending: T::Boolean,
+            html_options: Types::HtmlAttributeValue,
+            block: ContentBlock
+          ).void
+        end
+        def initialize(
+          title: nil,
+          body: nil,
+          color: :blue,
+          dot: nil,
+          position: nil,
+          loading: false,
+          parent: nil,
+          pending: false,
+          **html_options,
+          &block
+        )
+          @title = T.let(title, Types::Renderable)
+          @body = T.let(body, Types::Renderable)
+          @color = T.let(color.is_a?(String) ? color : color.to_sym, ColorValue)
+          @dot = T.let(dot, Types::Renderable)
+          @position = T.let(position, T.nilable(Symbol))
+          @loading = T.let(cast_boolean(loading) ? true : false, T::Boolean)
+          @parent = T.let(parent, T.nilable(HakumiComponents::Timeline::Component))
+          @pending = T.let(cast_boolean(pending) ? true : false, T::Boolean)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+          @content_block = T.let(block, ContentBlock)
+          @index = T.let(nil, T.nilable(Integer))
+          @total = T.let(nil, T.nilable(Integer))
+          @resolved_position = T.let(nil, T.nilable(Symbol))
+          @reverse = T.let(false, T::Boolean)
+          validate_props!
+        end
+
+        sig { returns(Types::Renderable) }
+        attr_reader :title, :body, :dot
+
+        sig { returns(ColorValue) }
+        attr_reader :color
+
+        sig { returns(T.nilable(Symbol)) }
+        attr_reader :position
+
+        sig { returns(T::Boolean) }
+        attr_reader :loading, :pending
+
+        sig { returns(T.nilable(HakumiComponents::Timeline::Component)) }
+        attr_reader :parent
+
+        sig do
+          params(
+            index: Integer,
+            total: Integer,
+            position: Symbol,
+            reverse: T::Boolean
+          ).returns(HakumiComponents::Timeline::Item::Component)
+        end
+        def with_context(index:, total:, position:, reverse: false)
+          @index = index
+          @total = total
+          @resolved_position = position
+          @reverse = reverse
+          self
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes(
+            {
+              class: item_classes,
+              data: item_data,
+              style: dot_style
+            },
+            @html_options
+          )
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def title_content
+          render_value(@title)
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def item_content
+          rendered_body = render_value(@body)
+          return rendered_body if rendered_body.present?
+          return content if content.present?
+
+          if @content_block && view_context
+            captured = view_context.capture(&@content_block)
+            return captured if captured.present?
+          end
+
+          nil
+        end
+
+        sig { returns(Symbol) }
+        def resolved_position
+          @resolved_position || @position || :left
+        end
+
+        sig { returns(T::Boolean) }
+        def last_item?
+          index = @index
+          total = @total
+          return false if index.nil? || total.nil?
+
+          @reverse ? index.zero? : index == (total - 1)
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def dot_content
+          rendered_dot = render_value(@dot)
+          return rendered_dot if rendered_dot.present?
+          return render(HakumiComponents::Icon::Component.new(name: :loading, spin: true, size: 12)) if loading
+
+          nil
+        end
+
+        private
+
+        sig { returns(String) }
+        def item_classes
+          component_classes(
+            "timeline-item",
+            {
+              resolved_position => true,
+              last: last_item?,
+              loading: loading,
+              pending: pending,
+              custom: value_present?(@dot)
+            },
+            @html_options
+          )
+        end
+
+        sig { returns(Types::DataAttributes) }
+        def item_data
+          { timeline_index: @index || 0 }
+        end
+
+        sig { returns(T.nilable(String)) }
+        def dot_style
+          color_value = color_value_for(color)
+          return nil if color_value.nil?
+
+          "--hakumi-timeline-dot-color: #{color_value};"
+        end
+
+        sig { params(value: ColorValue).returns(T.nilable(String)) }
+        def color_value_for(value)
+          return COLORS[value] if value.is_a?(Symbol) && COLORS.key?(value)
+          return value if value.is_a?(String)
+
+          nil
+        end
+
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:position, POSITIONS) unless @position.nil?
+          validate_inclusion!(:color, COLORS.keys) if @color.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@
     data-<%= stimulus_controller %>-target="trigger">
     <%= content %>
   </div>
-  <% if has_tooltip_content? %>
+  <% if tooltip_content? %>
     <div
       class="<%= tooltip_classes %>"
       role="tooltip"

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

@@ -0,0 +1,146 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tooltip
+      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, 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,
+        trigger: :hover,
+        arrow: true,
+        color: :default,
+        open: nil,
+        fresh: false,
+        **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
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      attr_reader :title
+
+      sig { returns(Symbol) }
+      attr_reader :placement, :trigger
+
+      sig { returns(T::Boolean) }
+      attr_reader :arrow, :fresh
+
+      sig { returns(Color) }
+      attr_reader :color
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :open
+
+      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
+
+      sig { returns(String) }
+      def tooltip_classes
+        class_names("tooltip", {}, [ placement_class, (color_class if preset_color?) ])
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def wrapper_attributes
+        values = {
+          placement: @placement.to_s.dasherize,
+          trigger: @trigger.to_s,
+          arrow: @arrow,
+          fresh: @fresh
+        }
+        values[:open] = @open unless @open.nil?
+        values[:color] = @color.to_s if custom_color?
+
+        merge_attributes(
+          { class: wrapper_classes, data: stimulus_attrs(stimulus_controller, values) },
+          @html_options
+        )
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def tooltip_text
+        render_value(@title)
+      end
+
+      sig { returns(T::Boolean) }
+      def tooltip_content?
+        value_present?(@title)
+      end
+
+      private
+
+      sig { returns(String) }
+      def placement_class
+        "hakumi-tooltip-placement-#{@placement.to_s.dasherize}"
+      end
+
+      sig { returns(T.nilable(String)) }
+      def color_class
+        "hakumi-tooltip-#{@color}" if preset_color?
+      end
+
+      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)
+        validate_inclusion!(:color, COLORS) if @color.is_a?(Symbol)
+      end
+      end
+  end
+end

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

@@ -0,0 +1,183 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tour
+    class Component < HakumiComponents::BaseComponent
+      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, 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,
+        mask: true,
+        mask_closable: true,
+        closable: true,
+        show_progress: true,
+        **html_options
+      )
+        @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(
+          {
+            id: @component_id,
+            class: component_html_class,
+            data: {
+              controller: "hakumi--tour",
+              hakumi__tour_open_value: @open,
+              hakumi__tour_current_value: @current,
+              hakumi__tour_steps_value: steps_json,
+              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_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
+      end
+
+      sig { returns(String) }
+      def 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?
+
+        "#{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
+
+        class_names("tour", modifiers, html_classes(@html_options))
+      end
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:type, TYPES)
+        validate_inclusion!(:placement, PLACEMENTS)
+        validate_steps!
+      end
+
+      sig { void }
+      def validate_steps!
+        @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 = 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.map(&:to_h).to_json
+      end
+
+      sig { returns(HakumiComponents::Tour::Step) }
+      def current_step
+        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
+    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