hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Tabs
-    module Item
-      class Component < Hakumi::BaseComponent
-        def initialize(
-          key:,
-          label: nil,
-          icon: nil,
-          disabled: false,
-          closable: false,
-          close_icon: nil,
-          force_render: false,
-          parent: nil,
-          **html_options
-        )
-          @key = key
-          @label = label
-          @icon = icon
-          @disabled = disabled
-          @closable = closable
-          @close_icon = close_icon
-          @force_render = force_render
-          @parent = parent
-          @html_options = html_options
-          @content = nil
-        end
-
-        attr_reader :key, :label, :icon, :disabled, :closable, :close_icon, :force_render
-        attr_accessor :content
-
-        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
-
-        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
-
-        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
-
-        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
-
-        def render_close_icon
-          @close_icon || :close
-        end
-      end
-    end
-  end
-end

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

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Tag
-    class Component < Hakumi::BaseComponent
-      COLORS = %i[magenta red volcano orange gold lime green cyan blue geekblue purple].freeze
-      STATUSES = %i[success processing error default warning].freeze
-      VARIANTS = %i[filled outlined borderless].freeze
-
-      renders_one :icon
-
-      def initialize(
-        color: nil,
-        closable: nil,
-        close_icon: nil,
-        bordered: nil,
-        variant: nil,
-        href: nil,
-        checkable: nil,
-        checked: nil,
-        draggable: nil,
-        **html_options
-      )
-        @color = color
-        @closable = closable || false
-        @close_icon = close_icon
-        @bordered = bordered.nil? ? true : bordered
-        @variant = (variant || :filled).to_sym
-        @href = href
-        @checkable = checkable || false
-        @checked = checked || false
-        @draggable = draggable || false
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def self.extract_controller_locals(params)
-        {
-          color: params[:color],
-          closable: params[:closable],
-          close_icon: params[:close_icon],
-          bordered: params[:bordered],
-          variant: params[:variant],
-          href: params[:href],
-          checkable: params[:checkable],
-          checked: params[:checked],
-          draggable: params[:draggable],
-          content: params[:content]
-        }
-      end
-
-      def call
-        if @href.present?
-          render_link_tag
-        else
-          render_span_tag
-        end
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:variant, VARIANTS) if @variant
-      end
-
-      def render_link_tag
-        content_tag(:a, tag_content, tag_attributes.merge(href: @href))
-      end
-
-      def render_span_tag
-        content_tag(:span, tag_content, tag_attributes)
-      end
-
-      def tag_content
-        safe_join([
-          icon_element,
-          content_wrapper,
-          close_button
-        ].compact)
-      end
-
-      def icon_element
-        return unless icon?
-        tag.span(icon, class: "hakumi-tag-icon")
-      end
-
-      def content_wrapper
-        content
-      end
-
-      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 Hakumi::Icon::Component.new(name: icon_name, size: 12)
-        end
-      end
-
-      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
-
-      def tag_classes
-        classes = [ "hakumi-tag" ]
-        classes << "hakumi-tag-#{@variant}" if @variant && @variant != :filled
-        classes << "hakumi-tag-#{preset_color}" if preset_color?
-        classes << "hakumi-tag-has-color" if custom_color?
-        classes << "hakumi-tag-#{status_color}" if status_color?
-        classes << "hakumi-tag-borderless" unless @bordered
-        classes << "hakumi-tag-checkable" if @checkable
-        classes << "hakumi-tag-checkable-checked" if @checkable && @checked
-        classes << "hakumi-tag-closable" if @closable
-        classes << "hakumi-tag-draggable" if @draggable
-        classes << @html_options[:class] if @html_options[:class]
-        classes.compact.join(" ")
-      end
-
-      def tag_data_attributes
-        data = {}
-
-        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
-
-      def preset_color?
-        @color.present? && COLORS.include?(@color.to_sym)
-      end
-
-      def preset_color
-        @color.to_sym if preset_color?
-      end
-
-      def status_color?
-        @color.present? && STATUSES.include?(@color.to_sym)
-      end
-
-      def status_color
-        @color.to_sym if status_color?
-      end
-
-      def custom_color?
-        @color.present? && !preset_color? && !status_color?
-      end
-
-      def custom_color_styles
-        return unless custom_color?
-
-        if @variant == :outlined
-          "border-color: #{@color}; color: #{@color};"
-        else
-          "background-color: #{@color}; border-color: #{@color}; color: #{contrast_color(@color)};"
-        end
-      end
-
-      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
-
-        r = hex[0..1].to_i(16)
-        g = hex[2..3].to_i(16)
-        b = hex[4..5].to_i(16)
-
-        luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
-
-        luminance > 0.5 ? "#000" : "#fff"
-      end
-    end
-  end
-end

data/app/components/hakumi/timeline/component.html.erb

@@ -1,7 +0,0 @@
-<%= tag.div(**wrapper_attributes) do %>
-  <div class="hakumi-timeline-items">
-    <% timeline_items.each_with_index do |item, index| %>
-      <%= render item.with_context(index: index, total: timeline_items.length, position: item_position(index, item), reverse: reverse) %>
-    <% end %>
-  </div>
-<% end %>

data/app/components/hakumi/timeline/component.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Timeline
-    class Component < Hakumi::BaseComponent
-      DIRECTIONS = %i[vertical horizontal].freeze
-      MODES = %i[left right alternate].freeze
-      VARIANTS = %i[filled outlined].freeze
-
-      renders_many :items, ->(
-        title: nil,
-        body: nil,
-        color: :blue,
-        dot: nil,
-        position: nil,
-        loading: false,
-        **options,
-        &block
-      ) do
-
-        Hakumi::Timeline::Item::Component.new(
-          title: title,
-          body: body,
-          color: color,
-          dot: dot,
-          position: position,
-          loading: loading,
-          parent: self,
-          **options,
-          &block
-        )
-      end
-
-      def initialize(
-        direction: :vertical,
-        mode: :left,
-        reverse: false,
-        pending: nil,
-        pending_dot: nil,
-        title_span: nil,
-        variant: :filled,
-        **html_options
-      )
-        @direction = direction
-        @mode = mode
-        @reverse = reverse
-        @pending = pending
-        @pending_dot = pending_dot
-        @title_span = title_span
-        @variant = variant
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      attr_reader :direction, :mode, :reverse, :pending, :pending_dot, :title_span, :variant
-
-      def self.extract_controller_locals(params)
-        {
-          direction: params[:direction],
-          mode: params[:mode],
-          reverse: params[:reverse],
-          pending: params[:pending],
-          pending_dot: params[:pending_dot],
-          title_span: params[:title_span],
-          variant: params[:variant],
-          items: parse_json_param(params[:items])
-        }
-      end
-
-      def self.parse_json_param(value)
-        return value unless value.is_a?(String)
-
-        JSON.parse(value)
-      rescue JSON::ParserError
-        value
-      end
-
-      def wrapper_attributes
-        base_attrs = {
-          class: timeline_classes,
-          style: timeline_style,
-          data: stimulus_data
-        }
-
-        merge_attributes(base_attrs, @html_options.except(:class))
-      end
-
-      def timeline_items
-        base_items = items.dup
-        base_items << pending_item if pending_item
-
-        return base_items.reverse if reverse
-
-        base_items
-      end
-
-      def item_position(index, item)
-        return item.position if item.position
-
-        case mode
-        when :right
-          :right
-        when :alternate
-          index.even? ? :left : :right
-        else
-          :left
-        end
-      end
-
-      def pending_item
-        return if pending.nil?
-
-        Hakumi::Timeline::Item::Component.new(
-          title: nil,
-          body: pending.is_a?(String) ? pending : nil,
-          loading: true,
-          dot: pending_dot,
-          parent: self,
-          pending: true
-        )
-      end
-
-      private
-
-      def stimulus_controller
-        "hakumi--timeline"
-      end
-
-      def stimulus_data
-        {
-          controller: stimulus_controller,
-          "#{stimulus_controller}-reverse-value" => reverse
-        }
-      end
-
-      def timeline_classes
-        class_names(
-          "timeline",
-          {
-            direction => true,
-            mode => mode != :left,
-            "reverse" => reverse,
-            "outlined" => variant == :outlined
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def timeline_style
-        span = normalized_title_span
-        return if span.blank?
-
-        "--hakumi-timeline-title-span: #{span};"
-      end
-
-      def validate_props!
-        validate_inclusion!(:direction, DIRECTIONS)
-        validate_inclusion!(:mode, MODES)
-        validate_inclusion!(:variant, VARIANTS)
-      end
-
-      def normalized_title_span
-        dimension_to_css(title_span)
-      end
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Timeline
-    module Item
-      class Component < Hakumi::BaseComponent
-        COLORS = {
-          blue: "var(--color-primary)",
-          red: "var(--color-error)",
-          green: "var(--color-success)",
-          gray: "var(--color-text-secondary)"
-        }.freeze
-        POSITIONS = %i[left right].freeze
-
-        def initialize(
-          title: nil,
-          body: nil,
-          color: :blue,
-          dot: nil,
-          position: nil,
-          loading: false,
-          parent: nil,
-          pending: false,
-          **html_options,
-          &block
-        )
-          @title = title
-          @body = body
-          @color = color
-          @dot = dot
-          @position = position
-          @loading = loading
-          @parent = parent
-          @pending = pending
-          @html_options = html_options
-          @content_block = block
-          validate_props!
-        end
-
-        attr_reader :title, :body, :color, :dot, :position, :loading, :parent, :pending
-
-        def with_context(index:, total:, position: nil, reverse: false)
-          @index = index
-          @total = total
-          @resolved_position = position
-          @reverse = reverse
-          self
-        end
-
-        def wrapper_attributes
-          base_attrs = {
-            class: item_classes,
-            data: item_data,
-            style: dot_style
-          }
-
-          merge_attributes(base_attrs, @html_options)
-        end
-
-        def item_content
-          return @body if @body.present?
-          return content if content.present?
-          return view_context.capture(&@content_block) if @content_block && view_context
-
-          nil
-        end
-
-        def resolved_position
-          @resolved_position || @position
-        end
-
-        def last_item?
-          # When reversed, the first item in the array (index 0) is the last visual item
-          # When not reversed, the last item in the array is the last visual item
-          if @reverse
-            @index == 0
-          else
-            @index == (@total.to_i - 1)
-          end
-        end
-
-        def dot_component?
-          dot.respond_to?(:render_in)
-        end
-
-        def dot_content
-          @dot_content ||= begin
-            if dot_component?
-              render(dot)
-            elsif dot.present?
-              dot
-            elsif loading
-              render(Hakumi::Icon::Component.new(name: :loading, spin: true, size: 12))
-            end
-          end
-        end
-
-        private
-
-        def item_classes
-          classes = [ "hakumi-timeline-item" ]
-          classes << "hakumi-timeline-item-#{resolved_position}" if resolved_position
-          classes << "hakumi-timeline-item-last" if last_item?
-          classes << "hakumi-timeline-item-loading" if loading
-          classes << "hakumi-timeline-item-pending" if pending
-          classes << "hakumi-timeline-item-custom" if dot.present?
-          classes.join(" ")
-        end
-
-        def item_data
-          { timeline_index: @index || 0 }
-        end
-
-        def dot_style
-          return unless color
-
-          color_value = color_value_for(color)
-          return unless color_value
-
-          "--hakumi-timeline-dot-color: #{color_value};"
-        end
-
-        def color_value_for(value)
-          return COLORS[value.to_sym] if value.is_a?(Symbol) && COLORS.key?(value.to_sym)
-          return value if value.is_a?(String)
-
-          nil
-        end
-
-        def validate_props!
-          validate_inclusion!(:position, POSITIONS) if @position
-          validate_inclusion!(:color, COLORS.keys) if @color.is_a?(Symbol)
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Tooltip
-    class Component < Hakumi::BaseComponent
-      TRIGGERS = %i[hover focus click].freeze
-      PLACEMENTS = %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
-
-      def initialize(
-        title: nil,
-        placement: :top,
-        trigger: :hover,
-        arrow: true,
-        color: :default,
-        open: nil,
-        fresh: false,
-        **html_options
-      )
-        @title = title
-        @placement = placement
-        @trigger = trigger
-        @arrow = arrow
-        @color = color
-        @open = open
-        @fresh = fresh
-        @html_options = html_options
-
-        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
-
-      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
-
-      def color_class
-        "hakumi-tooltip-#{@color}" if preset_color?
-      end
-
-      def preset_color?
-        @color.is_a?(Symbol) && @color != :default && COLORS.include?(@color)
-      end
-
-      def custom_color?
-        @color.is_a?(String)
-      end
-
-      def custom_color_style
-        return unless custom_color?
-        "background-color: #{@color};"
-      end
-
-      def stimulus_controller
-        "hakumi--tooltip"
-      end
-
-      def stimulus_values
-        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?
-        values
-      end
-
-      def wrapper_attributes
-        base_attrs = {
-          class: wrapper_classes,
-          data: {
-            controller: stimulus_controller
-          }.merge(stimulus_data_attributes)
-        }
-        merge_attributes(base_attrs, @html_options)
-      end
-
-      def stimulus_data_attributes
-        stimulus_values.transform_keys { |k| "#{stimulus_controller}-#{k.to_s.dasherize}-value" }
-      end
-
-      def tooltip_text
-        @title
-      end
-
-      def has_tooltip_content?
-        @title.present?
-      end
-
-      private
-
-      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