hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/tabs/indicator_config.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tabs
+    class IndicatorConfig
+      extend T::Sig
+
+      sig { params(size: T.nilable(Numeric), align: Symbol).void }
+      def initialize(size: nil, align: :center)
+        @size = T.let(size, T.nilable(Numeric))
+        @align = T.let(align, Symbol)
+      end
+
+      sig { returns(T.nilable(Numeric)) }
+      attr_reader :size
+
+      sig { returns(Symbol) }
+      attr_reader :align
+
+      sig { params(value: T.nilable(Types::HtmlAttributes)).returns(HakumiComponents::Tabs::IndicatorConfig) }
+      def self.coerce(value)
+        return new if value.nil?
+
+        raw_size = value[:size]
+        raw_align = value[:align]
+        new(
+          size: raw_size.is_a?(Numeric) ? raw_size : nil,
+          align: raw_align.is_a?(Symbol) ? raw_align : raw_align.is_a?(String) ? raw_align.to_sym : :center
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tabs
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        IconValue = T.type_alias { T.nilable(T.any(Symbol, ViewComponent::Base)) }
+
+        sig do
+          params(
+            key: Types::StringOrSymbol,
+            label: T.nilable(Types::Renderable),
+            icon: IconValue,
+            disabled: T::Boolean,
+            closable: T::Boolean,
+            close_icon: IconValue,
+            force_render: T::Boolean,
+            parent: T.nilable(HakumiComponents::Tabs::Component),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          key:,
+          label: nil,
+          icon: nil,
+          disabled: false,
+          closable: false,
+          close_icon: nil,
+          force_render: false,
+          parent: nil,
+          **html_options
+        )
+          @key = T.let(key, Types::StringOrSymbol)
+          @label = T.let(label, T.nilable(Types::Renderable))
+          @icon = T.let(icon, IconValue)
+          @disabled = T.let(disabled, T::Boolean)
+          @closable = T.let(closable, T::Boolean)
+          @close_icon = T.let(close_icon, IconValue)
+          @force_render = T.let(force_render, T::Boolean)
+          @parent = T.let(parent, T.nilable(HakumiComponents::Tabs::Component))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+          @content = T.let(nil, Types::RenderedContent)
+        end
+
+        sig { returns(Types::StringOrSymbol) }
+        attr_reader :key
+
+        sig { returns(T.nilable(Types::Renderable)) }
+        attr_reader :label
+
+        sig { returns(IconValue) }
+        attr_reader :icon, :close_icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled, :closable, :force_render
+
+        sig { returns(Types::RenderedContent) }
+        attr_reader :content
+
+        sig { params(value: Types::RenderedContent).void }
+        def content=(value)
+          @content = value
+        end
+
+        sig { params(active: T::Boolean).returns(String) }
+        def tab_classes(active)
+          classes = [ "hakumi-tabs-tab" ]
+          classes << "hakumi-tabs-tab-active" if active
+          classes << "hakumi-tabs-tab-disabled" if @disabled
+          classes << "hakumi-tabs-tab-with-remove" if @closable
+          classes.join(" ")
+        end
+
+        sig { params(active: T::Boolean).returns(Types::HtmlAttributes) }
+        def tab_attributes(active)
+          base_attrs = {
+            class: tab_classes(active),
+            role: "tab",
+            "aria-selected": active.to_s,
+            "aria-disabled": @disabled.to_s,
+            tabindex: active ? "0" : "-1",
+            data: {
+              "hakumi--tabs-target": "tab",
+              key: @key
+            }
+          }
+
+          unless @disabled
+            base_attrs[:data][:action] = "click->hakumi--tabs#selectTab"
+          end
+
+          merge_attributes(base_attrs, @html_options.except(:class))
+        end
+
+        sig { params(active: T::Boolean).returns(String) }
+        def pane_classes(active)
+          classes = [ "hakumi-tabs-tabpane" ]
+          classes << "hakumi-tabs-tabpane-active" if active
+          classes << "hakumi-tabs-tabpane-hidden" unless active
+          classes.join(" ")
+        end
+
+        sig { params(active: T::Boolean).returns(Types::HtmlAttributes) }
+        def pane_attributes(active)
+          {
+            class: pane_classes(active),
+            role: "tabpanel",
+            "aria-hidden": (!active).to_s,
+            tabindex: active ? "0" : "-1",
+            data: {
+              "hakumi--tabs-target": "pane",
+              key: @key
+            }
+          }
+        end
+
+        sig { returns(Symbol) }
+        def render_close_icon
+          icon = @close_icon
+          return icon if icon.is_a?(Symbol)
+
+          :close
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def display_label
+          label_value = @label
+          return @key.to_s if label_value.nil?
+          return label_value if label_value.is_a?(String) || label_value.is_a?(ActiveSupport::SafeBuffer)
+
+          render(label_value)
+        end
+
+        sig { returns(T.nilable(ViewComponent::Base)) }
+        def icon_component
+          raw_icon = @icon
+          return nil if raw_icon.nil?
+
+          raw_icon.is_a?(Symbol) ? HakumiComponents::Icon::Component.new(name: raw_icon) : raw_icon
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,282 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tag
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Color = T.type_alias { T.nilable(T.any(Symbol, String)) }
+      Variant = T.type_alias { T.any(Symbol, String) }
+      IconName = T.type_alias { T.nilable(T.any(Symbol, String)) }
+
+      COLORS = T.let(%i[magenta red volcano orange gold lime green cyan blue geekblue purple].freeze, T::Array[Symbol])
+      STATUSES = T.let(%i[success processing error default warning].freeze, T::Array[Symbol])
+      VARIANTS = T.let(%i[filled outlined borderless].freeze, T::Array[Symbol])
+
+      renders_one :icon
+
+      sig do
+        params(
+          color: Color,
+          closable: T.nilable(T::Boolean),
+          close_icon: IconName,
+          bordered: T.nilable(T::Boolean),
+          variant: T.nilable(Variant),
+          href: T.nilable(String),
+          checkable: T.nilable(T::Boolean),
+          checked: T.nilable(T::Boolean),
+          draggable: T.nilable(T::Boolean),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        color: nil,
+        closable: nil,
+        close_icon: nil,
+        bordered: nil,
+        variant: nil,
+        href: nil,
+        checkable: nil,
+        checked: nil,
+        draggable: nil,
+        **html_options
+      )
+        @color = T.let(color, Color)
+        @closable = T.let(cast_boolean(closable) ? true : false, T::Boolean)
+        @close_icon = T.let(close_icon, IconName)
+        @bordered = T.let(cast_boolean(bordered) != false, T::Boolean)
+        @variant = T.let((variant || :filled).to_sym, Symbol)
+        @href = T.let(href, T.nilable(String))
+        @checkable = T.let(cast_boolean(checkable) ? true : false, T::Boolean)
+        @checked = T.let(cast_boolean(checked) ? true : false, T::Boolean)
+        @draggable = T.let(cast_boolean(draggable) ? true : false, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          color: html_primitive_param(html_param(params, :color)),
+          closable: boolean_html_param(html_param(params, :closable)),
+          close_icon: html_primitive_param(html_param(params, :close_icon)),
+          bordered: boolean_html_param(html_param(params, :bordered)),
+          variant: symbol_html_param(html_param(params, :variant)),
+          href: html_primitive_param(html_param(params, :href)),
+          checkable: boolean_html_param(html_param(params, :checkable)),
+          checked: boolean_html_param(html_param(params, :checked)),
+          draggable: boolean_html_param(html_param(params, :draggable)),
+          content: html_primitive_param(html_param(params, :content))
+        }
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        if @href.present?
+          render_link_tag
+        else
+          render_span_tag
+        end
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:variant, VARIANTS)
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def render_link_tag
+        content_tag(:a, tag_content, tag_attributes.merge(href: @href))
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def render_span_tag
+        content_tag(:span, tag_content, tag_attributes)
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def tag_content
+        safe_join([
+          icon_element,
+          content_wrapper,
+          close_button
+        ].compact)
+      end
+
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
+      def icon_element
+        return unless icon?
+        tag.span(icon, class: "hakumi-tag-icon")
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def content_wrapper
+        render_value(content)
+      end
+
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
+      def close_button
+        return unless @closable
+
+        icon_name = @close_icon || "close"
+        tag.span(class: "hakumi-tag-close-icon", data: { action: "click->hakumi--tag#close" }) do
+          render HakumiComponents::Icon::Component.new(name: icon_name, size: 12)
+        end
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def tag_attributes
+        attrs = {
+          class: tag_classes,
+          data: tag_data_attributes
+        }
+
+        attrs[:style] = custom_color_styles if custom_color?
+        attrs[:draggable] = true if @draggable
+
+        merge_attributes(attrs, @html_options)
+      end
+
+      sig { returns(String) }
+      def tag_classes
+        extras = T.let([], T::Array[T.nilable(String)])
+        extras << "hakumi-tag-#{@variant}" if @variant != :filled
+        extras << "hakumi-tag-#{preset_color}" if preset_color?
+        extras << "hakumi-tag-#{status_color}" if status_color?
+        append_html_classes!(extras, @html_options)
+
+        class_names(
+          "tag",
+          {
+            "has-color": custom_color?,
+            borderless: !@bordered,
+            checkable: @checkable,
+            "checkable-checked": @checkable && @checked,
+            closable: @closable,
+            draggable: @draggable
+          },
+          extras
+        )
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def tag_data_attributes
+        data = T.let({}, Types::DataAttributes)
+
+        if @closable || @checkable
+          data[:controller] = "hakumi--tag"
+        end
+
+        data[:hakumi__tag_checkable_value] = @checkable if @checkable
+        data[:hakumi__tag_checked_value] = @checked if @checkable
+
+        data
+      end
+
+      sig { returns(T::Boolean) }
+      def preset_color?
+        color_key = color_symbol
+        !color_key.nil? && COLORS.include?(color_key)
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def preset_color
+        color_key = color_symbol
+        return nil unless color_key && COLORS.include?(color_key)
+
+        color_key
+      end
+
+      sig { returns(T::Boolean) }
+      def status_color?
+        color_key = color_symbol
+        !color_key.nil? && STATUSES.include?(color_key)
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def status_color
+        color_key = color_symbol
+        return nil unless color_key && STATUSES.include?(color_key)
+
+        color_key
+      end
+
+      sig { returns(T::Boolean) }
+      def custom_color?
+        @color.present? && !preset_color? && !status_color?
+      end
+
+      sig { returns(T.nilable(String)) }
+      def custom_color_styles
+        return unless custom_color?
+
+        color = color_string
+        return nil unless color
+
+        if @variant == :outlined
+          "border-color: #{color}; color: #{color};"
+        else
+          "background-color: #{color}; border-color: #{color}; color: #{contrast_color(color)};"
+        end
+      end
+
+      sig { params(hex_color: String).returns(String) }
+      def contrast_color(hex_color)
+        return "#fff" unless hex_color.start_with?("#")
+
+        hex = hex_color.delete("#")
+        hex = hex.chars.map { |c| c * 2 }.join if hex.length == 3
+        return "#fff" unless hex.length == 6
+
+        red = hex[0, 2]
+        green = hex[2, 2]
+        blue = hex[4, 2]
+        return "#fff" if red.nil? || green.nil? || blue.nil?
+
+        r = red.to_i(16)
+        g = green.to_i(16)
+        b = blue.to_i(16)
+
+        luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
+
+        luminance > 0.5 ? "#000" : "#fff"
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def color_symbol
+        return @color if @color.is_a?(Symbol)
+        return @color.to_sym if @color.is_a?(String) && @color.present?
+
+        nil
+      end
+
+      sig { returns(T.nilable(String)) }
+      def color_string
+        return @color if @color.is_a?(String) && @color.present?
+        return @color.to_s if @color.is_a?(Symbol)
+
+        nil
+      end
+
+      sig { params(extras: T::Array[T.nilable(String)], attributes: Types::HtmlAttributes).void }
+      def append_html_classes!(extras, attributes)
+        existing_classes = html_classes(attributes)
+        return if existing_classes.nil?
+
+        if existing_classes.is_a?(Array)
+          extras.concat(existing_classes)
+        else
+          extras << existing_classes
+        end
+      end
+    end
+  end
+end

data/app/components/{hakumi → hakumi_components}/tag/group/component.rb

@@ -1,25 +1,37 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Tag
     module Group
-      class Component < Hakumi::BaseComponent
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            sortable: T.nilable(T::Boolean),
+            animation: T.nilable(Integer),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           sortable: nil,
           animation: nil,
           **html_options
         )
-          @sortable = sortable || false
-          @animation = animation || 150
-          @html_options = html_options
+          @sortable = T.let(sortable || false, T::Boolean)
+          @animation = T.let(animation || 150, Integer)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
+        sig { returns(ActiveSupport::SafeBuffer) }
         def call
           content_tag(:div, content, tag_group_attributes)
         end
 
         private
 
+        sig { returns(Types::HtmlAttributes) }
         def tag_group_attributes
           attrs = {
             class: tag_group_classes,
@@ -29,12 +41,12 @@ module Hakumi
           merge_attributes(attrs, @html_options)
         end
 
+        sig { returns(String) }
         def tag_group_classes
-          classes = [ "hakumi-tag-group" ]
-          classes << @html_options[:class] if @html_options[:class]
-          classes.compact.join(" ")
+          component_classes("tag-group", {}, @html_options)
         end
 
+        sig { returns(Types::DataAttributes) }
         def tag_group_data
           {
             controller: "hakumi--tag-group",

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

@@ -8,25 +8,25 @@
               data-hakumi--time-picker-target="clearBtn"
               data-action="click->hakumi--time-picker#clear"
               style="<%= current_value.present? ? '' : 'display: none;' %>">
-          <%= render Hakumi::Icon::Component.new(name: :close_circle, theme: :filled) %>
+          <%= render HakumiComponents::Icon::Component.new(name: :close_circle, theme: :filled) %>
         </span>
       <% end %>
 
       <span class="hakumi-time-picker-suffix">
-        <%= render Hakumi::Icon::Component.new(name: :clock_circle, fallback_to_outlined: true) %>
+        <%= render HakumiComponents::Icon::Component.new(name: :clock_circle, fallback_to_outlined: true) %>
       </span>
     </div>
 
     <div class="hakumi-time-picker-dropdown hakumi-time-picker-dropdown-hidden" data-hakumi--time-picker-target="dropdown">
       <div class="hakumi-time-picker-panel">
         <%= render partial: "hakumi/time_picker/columns", locals: {
-          formatted_hours: formatted_hours,
-          formatted_minutes: formatted_minutes,
-          formatted_seconds: formatted_seconds,
-          show_seconds: show_seconds?,
-          use_12_hours: @use_12_hours,
-          period_options: period_options,
-          controller: "hakumi--time-picker"
+              formatted_hours: formatted_hours,
+              formatted_minutes: formatted_minutes,
+              formatted_seconds: formatted_seconds,
+              show_seconds: show_seconds?,
+              use_12_hours: use_12_hours?,
+              period_options: period_options,
+              controller: "hakumi--time-picker"
         } %>
       </div>
 
@@ -44,7 +44,7 @@
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= time_picker_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>