hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,219 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Descriptions
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      LAYOUTS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      COLUMN_BREAKPOINTS = T.let(%i[xs sm md lg xl xxl].freeze, T::Array[Symbol])
+
+      renders_one :title
+      renders_one :extra
+
+      renders_many :items, ->(
+        label:,
+        content: nil,
+        span: 1,
+        label_style: nil,
+        content_style: nil,
+        &block
+      ) do
+        item = HakumiComponents::Descriptions::Item::Component.new(
+          label: label,
+          content: content,
+          span: span,
+          label_style: label_style,
+          content_style: content_style
+        )
+        item.content = capture(&block) if block
+        item
+      end
+
+      sig do
+        params(
+          title: Types::Renderable,
+          extra: Types::Renderable,
+          bordered: T::Boolean,
+          size: Symbol,
+          layout: Symbol,
+          column: T.any(Integer, T::Hash[Symbol, Integer]),
+          colon: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        title: nil,
+        extra: nil,
+        bordered: false,
+        size: :default,
+        layout: :horizontal,
+        column: 3,
+        colon: true,
+        **html_options
+      )
+        @title = T.let(title, Types::Renderable)
+        @extra = T.let(extra, Types::Renderable)
+        @bordered = T.let(cast_boolean(bordered) ? true : false, T::Boolean)
+        @size = T.let(size.to_sym, Symbol)
+        @layout = T.let(layout.to_sym, Symbol)
+        @column = T.let(normalize_column(column), T.any(Integer, T::Hash[Symbol, Integer]))
+        @colon = T.let(cast_boolean(colon) != false, T::Boolean)
+        @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)
+      end
+
+      sig { returns(T::Boolean) }
+      def header?
+        title_content.present? || extra_content.present?
+      end
+
+      sig { returns(T::Boolean) }
+      def vertical_layout?
+        @layout == :vertical
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def title_content
+        return render_value(title) if title?
+
+        render_value(@title)
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def extra_content
+        return render_value(extra) if extra?
+
+        render_value(@extra)
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:layout, LAYOUTS)
+      end
+
+      sig { returns(Integer) }
+      def max_column_count
+        if @column.is_a?(Integer)
+          @column.positive? ? @column : 3
+        else
+          values = @column.values
+          return 3 if values.empty?
+
+          values.reduce(0) { |max, value| value > max ? value : max }
+        end
+      end
+
+      sig { returns(T::Array[T::Array[[ HakumiComponents::Descriptions::Item::Component, Integer ]]]) }
+      def rows
+        cols = max_column_count
+        result = T.let([], T::Array[T::Array[[ HakumiComponents::Descriptions::Item::Component, Integer ]]])
+        current_row = T.let([], T::Array[[ HakumiComponents::Descriptions::Item::Component, Integer ]])
+        current_span = T.let(0, Integer)
+
+        items.each do |item|
+          span = item.span.positive? ? item.span : 1
+          span = cols if span > cols
+
+          if current_span + span > cols && !current_row.empty?
+            result << current_row
+            current_row = []
+            current_span = 0
+          end
+
+          current_row << [ item, span ]
+          current_span += span
+        end
+
+        result << current_row unless current_row.empty?
+
+        result.map do |row|
+          total_span = row.sum { |(_, span)| span }
+          if total_span < cols && !row.empty?
+            remaining = cols - total_span
+            last_item, last_span = row.fetch(row.length - 1)
+            prefix = row[0, row.length - 1] || []
+            prefix + [ [ last_item, last_span + remaining ] ]
+          else
+            row
+          end
+        end
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        extras = T.let(build_column_classes, T::Array[String])
+        existing_classes = html_classes(@html_options)
+        if existing_classes.is_a?(Array)
+          extras.concat(existing_classes.compact)
+        elsif existing_classes.is_a?(String)
+          extras << existing_classes
+        end
+
+        class_names(
+          "descriptions",
+          {
+            bordered: @bordered,
+            small: @size == :small,
+            default: @size == :default,
+            vertical: vertical_layout?
+          },
+          extras
+        )
+      end
+
+      sig { returns(T::Array[String]) }
+      def build_column_classes
+        base = T.let([], T::Array[String])
+
+        case @column
+        when Integer
+          base << "hakumi-descriptions-column-#{@column}"
+        when Hash
+          default_col = @column[:column] || @column[:default]
+          base << "hakumi-descriptions-column-#{default_col}" if default_col
+
+          COLUMN_BREAKPOINTS.each do |bp|
+            value = @column[bp]
+            next unless value
+
+            base << "hakumi-descriptions-column-#{bp}-#{value}"
+          end
+        end
+
+        base
+      end
+
+      sig { returns(String) }
+      def label_cell_classes
+        class_names("descriptions-item-label", { colon: @colon && !vertical_layout? })
+      end
+
+      sig { returns(String) }
+      def content_cell_classes
+        "hakumi-descriptions-item-content"
+      end
+
+      sig { params(column: T.any(Integer, T::Hash[Symbol, Integer])).returns(T.any(Integer, T::Hash[Symbol, Integer])) }
+      def normalize_column(column)
+        return column if column.is_a?(Integer)
+
+        normalized = T.let({}, T::Hash[Symbol, Integer])
+        column.each do |key, value|
+          normalized[key.to_sym] = value
+        end
+        normalized
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Descriptions
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig { returns(Types::Renderable) }
+        attr_reader :label, :content
+
+        sig { returns(Integer) }
+        attr_reader :span
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label_style, :content_style
+
+        sig do
+          params(
+            label: Types::Renderable,
+            content: Types::Renderable,
+            span: Integer,
+            label_style: T.nilable(String),
+            content_style: T.nilable(String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          label:,
+          content: nil,
+          span: 1,
+          label_style: nil,
+          content_style: nil,
+          **html_options
+        )
+          @label = T.let(label, Types::Renderable)
+          @content = T.let(content, Types::Renderable)
+          @span = T.let(span, Integer)
+          @label_style = T.let(label_style, T.nilable(String))
+          @content_style = T.let(content_style, T.nilable(String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { params(value: Types::Renderable).returns(Types::Renderable) }
+        def content=(value)
+          @content = value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Divider
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      ORIENTATIONS = T.let([ :horizontal, :vertical ].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let([ :left, :center, :right ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          orientation: Symbol,
+          dashed: T::Boolean,
+          plain: T::Boolean,
+          orientation_margin: T.nilable(Symbol),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        orientation: :horizontal,
+        dashed: false,
+        plain: false,
+        orientation_margin: nil,
+        **html_options
+      )
+        @orientation = T.let(orientation, Symbol)
+        @dashed = T.let(dashed, T::Boolean)
+        @plain = T.let(plain, T::Boolean)
+        @orientation_margin = T.let(orientation_margin, T.nilable(Symbol))
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        if @orientation == :vertical
+          content_tag(:span, nil, wrapper_attributes)
+        else
+          content_tag(:div, content_wrapper, wrapper_attributes)
+        end
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:orientation, ORIENTATIONS)
+        validate_inclusion!(:orientation_margin, PLACEMENTS) if @orientation_margin
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        with_text = @orientation == :horizontal && content.present?
+        modifiers = {
+          @orientation => true,
+          dashed: @dashed,
+          "with-text": with_text,
+          plain: @plain && with_text
+        }
+        modifiers[:"with-text-#{@orientation_margin}"] = true if with_text && @orientation_margin
+
+        class_names("divider", modifiers, html_classes(@html_options))
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def wrapper_attributes
+        attrs = T.let({
+          class: wrapper_classes,
+          role: "separator"
+        }, HakumiComponents::Types::HtmlAttributes)
+
+        merge_attributes(attrs, @html_options.except(:class))
+      end
+
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
+      def content_wrapper
+        return nil if content.blank?
+
+        tag.span(content, class: "hakumi-divider-inner-text")
+      end
+    end
+  end
+end

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

@@ -19,12 +19,12 @@
               <% if @closable %>
                 <button type="button" class="hakumi-drawer-close" aria-label="Close" data-hakumi-action="close">
                   <span class="hakumi-drawer-close-x">
-                    <%= render Hakumi::Icon::Component.new(name: :close) %>
+                    <%= render HakumiComponents::Icon::Component.new(name: :close) %>
                   </span>
                 </button>
               <% end %>
-              <% if header? %>
-                <div class="hakumi-drawer-title"><%= header %></div>
+              <% if header_content.present? %>
+                <div class="hakumi-drawer-title"><%= header_content %></div>
               <% end %>
             </div>
             <% if extra? %>

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

@@ -0,0 +1,191 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Drawer
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+      Placement = T.type_alias { Types::HtmlKey }
+      Size = T.type_alias { T.any(Integer, Types::HtmlKey) }
+      ResolvedSize = T.type_alias { T.any(Symbol, Integer) }
+
+      PLACEMENTS = T.let(%i[left right top bottom].freeze, T::Array[Symbol])
+      SIZES = T.let({
+        default: 378,
+        large: 736
+      }.freeze, T::Hash[Symbol, Integer])
+
+      renders_one :header
+      renders_one :body
+      renders_one :footer
+      renders_one :extra
+
+      sig do
+        params(
+          params: BaseComponent::ControllerOptions
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          open: boolean_html_param(html_param(params, :open)),
+          placement: symbol_html_param(html_param(params, :placement)),
+          size: size_param(html_param(params, :size)),
+          width: integer_html_param(html_param(params, :width)),
+          height: integer_html_param(html_param(params, :height)),
+          closable: boolean_html_param(html_param(params, :closable) || true),
+          mask: boolean_html_param(html_param(params, :mask) || true),
+          mask_closable: boolean_html_param(html_param(params, :mask_closable) || true),
+          keyboard: boolean_html_param(html_param(params, :keyboard) || true),
+          destroy_on_close: boolean_html_param(html_param(params, :destroy_on_close)),
+          title: html_primitive_param(html_param(params, :title)),
+          message: html_primitive_param(html_param(params, :message))
+        }.compact
+      end
+
+      sig do
+        params(
+          title: HakumiComponents::Types::Renderable,
+          message: HakumiComponents::Types::Renderable,
+          open: T::Boolean,
+          placement: Placement,
+          size: Size,
+          width: T.nilable(Integer),
+          height: T.nilable(Integer),
+          closable: T::Boolean,
+          mask: T::Boolean,
+          mask_closable: T::Boolean,
+          keyboard: T::Boolean,
+          destroy_on_close: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        title: nil,
+        message: nil,
+        open: false,
+        placement: :right,
+        size: :default,
+        width: nil,
+        height: nil,
+        closable: true,
+        mask: true,
+        mask_closable: true,
+        keyboard: true,
+        destroy_on_close: false,
+        **html_options
+      )
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @message = T.let(message, HakumiComponents::Types::Renderable)
+        @open = T.let(open, T::Boolean)
+        @placement = T.let(placement.to_sym, Symbol)
+        @size = T.let(size.is_a?(String) ? size.to_sym : size, ResolvedSize)
+        @width = T.let(width, T.nilable(Integer))
+        @height = T.let(height, T.nilable(Integer))
+        @closable = T.let(closable, T::Boolean)
+        @mask = T.let(mask, T::Boolean)
+        @mask_closable = T.let(mask_closable, T::Boolean)
+        @keyboard = T.let(keyboard, T::Boolean)
+        @destroy_on_close = T.let(destroy_on_close, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(String) }
+      def drawer_classes
+        class_names("drawer", { @placement => true, open: @open })
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def root_attributes
+        base_attrs = {
+          class: drawer_classes,
+          data: data_attributes
+        }
+
+        merge_attributes(base_attrs, @html_options)
+      end
+
+      sig { returns(HakumiComponents::Types::DataAttributes) }
+      def data_attributes
+        data = T.let({
+          controller: "hakumi--drawer",
+          hakumi__drawer_open_value: @open,
+          hakumi__drawer_placement_value: @placement.to_s,
+          hakumi__drawer_mask_closable_value: @mask_closable,
+          hakumi__drawer_keyboard_value: @keyboard,
+          hakumi__drawer_destroy_on_close_value: @destroy_on_close
+        }, HakumiComponents::Types::DataAttributes)
+        existing = @html_options[:data]
+        existing.each { |key, value| data[key] = value } if existing.is_a?(Hash)
+        data
+      end
+
+      sig { returns(String) }
+      def wrapper_style
+        size_value = resolve_size
+        if %i[left right].include?(@placement)
+          "width: #{dimension_to_css(@width || size_value)};"
+        else
+          "height: #{dimension_to_css(@height || size_value)};"
+        end
+      end
+
+      sig { returns(T::Boolean) }
+      def render_header?
+        header? || value_present?(@title) || @closable || extra?
+      end
+
+      sig { returns(T::Boolean) }
+      def render_footer?
+        footer?
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def body_content
+        return render_value(body) if body?
+        return render_value(content) if content.present?
+
+        render_value(@message)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def header_content
+        return render_value(header) if header?
+
+        render_value(@title)
+      end
+
+      private
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: HakumiComponents::Types::HtmlAttributeValue).returns(T.nilable(ResolvedSize)) }
+        def size_param(value)
+          return value if value.is_a?(Integer)
+          return symbol_html_param(value) if value.is_a?(String) || value.is_a?(Symbol)
+
+          nil
+        end
+      end
+
+      sig { returns(Integer) }
+      def resolve_size
+        return @size if @size.is_a?(Integer)
+
+        value = SIZES[@size]
+        value.nil? ? SIZES.fetch(:default) : value
+      end
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:placement, PLACEMENTS)
+        validate_inclusion!(:size, SIZES.keys) if @size.is_a?(Symbol)
+      end
+      end
+  end
+end

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

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Dropdown
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      TRIGGERS = T.let(%i[hover click context_menu].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let(%i[bottom bottom_left bottom_right top top_left top_right].freeze, T::Array[Symbol])
+
+      renders_one :trigger
+      renders_many :items, types: {
+        item: {
+          renders: HakumiComponents::Dropdown::Item::Component,
+          as: :item
+        },
+        divider: {
+          renders: -> { HakumiComponents::Dropdown::Divider::Component.new },
+          as: :divider
+        }
+      }
+
+      sig do
+        params(
+          trigger: Symbol,
+          placement: Symbol,
+          disabled: T::Boolean,
+          arrow: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        trigger: :hover,
+        placement: :bottom_left,
+        disabled: false,
+        arrow: false,
+        **html_options
+      )
+        @trigger = T.let(trigger, Symbol)
+        @placement = T.let(placement, Symbol)
+        @disabled = T.let(disabled, T::Boolean)
+        @arrow = T.let(arrow, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      private
+
+      sig { returns(String) }
+      def dropdown_classes
+        extra = @disabled ? "hakumi-dropdown-disabled" : nil
+        class_names("dropdown-trigger", {}, extra)
+      end
+
+      sig { returns(String) }
+      def menu_classes
+        "hakumi-dropdown-menu"
+      end
+
+      sig { returns(String) }
+      def stimulus_controller
+        "hakumi--dropdown"
+      end
+
+      sig { returns(String) }
+      def placement_class
+        "hakumi-dropdown-placement-#{@placement.to_s.dasherize}"
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        base_data = T.let({
+          controller: stimulus_controller,
+          "#{stimulus_controller}-trigger-value" => @trigger.to_s,
+          "#{stimulus_controller}-placement-value" => @placement.to_s.dasherize,
+          "#{stimulus_controller}-disabled-value" => @disabled.to_s
+        }, Types::DataAttributes)
+
+        merge_attributes(
+          { class: dropdown_classes, data: base_data },
+          @html_options
+        )
+      end
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:trigger, TRIGGERS)
+        validate_inclusion!(:placement, PLACEMENTS)
+      end
+    end
+  end
+end

data/app/components/{hakumi → hakumi_components}/dropdown/divider/component.rb

@@ -1,9 +1,13 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Dropdown
     module Divider
-      class Component < Hakumi::BaseComponent
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig { returns(ActiveSupport::SafeBuffer) }
         def call
           tag.li(class: "hakumi-dropdown-menu-item-divider", role: "separator")
         end