hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Dropdown
-    module Item
-      class Component < Hakumi::BaseComponent
-        def initialize(key:, label: nil, href: nil, target: nil, icon: nil, disabled: false, danger: false, **html_options)
-          @key = key
-          @label = label
-          @href = href
-          @target = target
-          @icon = icon
-          @disabled = disabled
-          @danger = danger
-          @html_options = html_options
-        end
-
-        attr_reader :key, :label, :href, :target, :icon, :disabled, :danger
-
-        def item_classes
-          classes = [ "hakumi-dropdown-menu-item" ]
-          classes << "hakumi-dropdown-menu-item-disabled" if disabled
-          classes << "hakumi-dropdown-menu-item-danger" if danger
-          classes.join(" ")
-        end
-
-        def link?
-          href.present?
-        end
-
-        def display_label
-          content.presence || label
-        end
-
-        def icon_component
-          return nil unless icon
-
-          if icon.is_a?(Symbol)
-            Hakumi::Icon::Component.new(name: icon)
-          else
-            icon
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Flex
-    class Component < Hakumi::BaseComponent
-      WRAP_OPTIONS = [ :wrap, :nowrap, :"wrap-reverse" ].freeze
-      JUSTIFY_OPTIONS = [ :start, :end, :center, :"space-between", :"space-around", :"space-evenly" ].freeze
-      ALIGN_OPTIONS = [ :start, :end, :center, :baseline, :stretch ].freeze
-      GAP_OPTIONS = [ :small, :middle, :large ].freeze
-
-      def initialize(
-        vertical: false,
-        wrap: :nowrap,
-        justify: :start,
-        align: :start,
-        gap: nil,
-        component: :div,
-        **html_options
-      )
-        @vertical = vertical
-
-        @wrap = normalize_prop(wrap)
-        @justify = normalize_prop(justify)
-        @align = align
-        @gap = gap
-        @component = component
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def call
-        content_tag(@component, content, wrapper_attributes)
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:wrap, WRAP_OPTIONS) if @wrap.is_a?(Symbol)
-        validate_inclusion!(:justify, JUSTIFY_OPTIONS)
-        validate_inclusion!(:align, ALIGN_OPTIONS)
-        validate_inclusion!(:gap, GAP_OPTIONS) if @gap.is_a?(Symbol)
-      end
-
-      def wrapper_classes
-        class_names(
-          "flex",
-          {
-            vertical: @vertical,
-            "wrap-#{@wrap}": @wrap != :nowrap,
-            "justify-#{@justify}": @justify != :start,
-            "align-#{@align}": @align != :start,
-            "gap-#{@gap}": @gap.is_a?(Symbol)
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def wrapper_attributes
-        attrs = {
-          class: wrapper_classes
-        }
-
-        # Handle numeric gap or custom gap string
-        if @gap.present? && !@gap.is_a?(Symbol)
-          attrs[:style] = "gap: #{@gap.is_a?(Numeric) ? "#{@gap}px" : @gap};"
-        end
-
-        merge_attributes(attrs, @html_options.except(:class))
-      end
-
-      def normalize_prop(prop)
-        return prop unless prop.is_a?(Symbol)
-        prop.to_s.tr("_", "-").to_sym
-      end
-    end
-  end
-end

data/app/components/hakumi/float_button/back_top/component.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module FloatButton
-    module BackTop
-      class Component < Hakumi::BaseComponent
-        DEFAULT_VISIBILITY = 400
-
-        def initialize(
-          icon: :vertical_align_top,
-          tooltip: "Back to top",
-          visibility_height: DEFAULT_VISIBILITY,
-          target_selector: nil,
-          floating: true,
-          placement: :bottom_right,
-          offset: nil,
-          button_options: {},
-          **html_options
-        )
-          @icon = icon
-          @tooltip = tooltip
-          @visibility_height = visibility_height
-          @target_selector = target_selector
-          @floating = floating
-          @placement = placement
-          @offset = offset
-          @button_options = button_options
-          @html_options = html_options
-        end
-
-        def call
-          render Hakumi::FloatButton::Component.new(
-            icon: @icon,
-            tooltip: @tooltip,
-            floating: @floating,
-            placement: @placement,
-            offset: @offset,
-            button_options: back_top_button_options,
-            **back_top_html_options
-          )
-        end
-
-        private
-
-        def back_top_html_options
-          options = @html_options.deep_dup
-          options[:class] = class_names("float-button-back-top", {}, [ @html_options[:class] ])
-
-          data = (options[:data] || {}).dup
-          data[:controller] = append_controller(data[:controller], "hakumi--float-button-back-top")
-          data["hakumi--float-button-back-top-visibility-height-value"] = @visibility_height
-          data["hakumi--float-button-back-top-target-selector-value"] = @target_selector if @target_selector.present?
-          options[:data] = data
-          options
-        end
-
-        def back_top_button_options
-          options = @button_options.deep_dup
-          data = (options[:data] || {}).dup
-          data[:action] = append_action(data[:action], "click->hakumi--float-button-back-top#scroll")
-          options[:data] = data
-          options
-        end
-
-        def append_controller(existing, controller)
-          return controller if existing.blank?
-
-          [ existing, controller ].join(" ")
-        end
-
-        def append_action(existing, action)
-          return action if existing.blank?
-
-          [ existing, action ].join(" ")
-        end
-      end
-    end
-  end
-end

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

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module FloatButton
-    class Component < Hakumi::BaseComponent
-      TYPES = [ :default, :primary ].freeze
-      SHAPES = [ :circle, :square ].freeze
-      PLACEMENTS = {
-        bottom_right: { bottom: 24, right: 24 },
-        bottom_left: { bottom: 24, left: 24 },
-        top_right: { top: 24, right: 24 },
-        top_left: { top: 24, left: 24 }
-      }.freeze
-
-      def initialize(
-        icon: :plus,
-        description: nil,
-        tooltip: nil,
-        href: nil,
-        target: nil,
-        shape: :circle,
-        type: :default,
-        danger: false,
-        badge: nil,
-        floating: true,
-        placement: :bottom_right,
-        offset: nil,
-        button_options: {},
-        **html_options
-      )
-        @icon = icon
-        @description = description
-        @tooltip = tooltip
-        @href = href
-        @target = target
-        @shape = shape
-        @type = type
-        @danger = danger
-        @badge = badge
-        @floating = floating
-        @placement = placement
-        @offset = offset
-        @button_options = button_options
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def call
-        wrap_with_badge(float_button_markup)
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:shape, SHAPES)
-        validate_inclusion!(:type, TYPES)
-        validate_inclusion!(:placement, PLACEMENTS.keys)
-        validate_description_support!
-      end
-
-      def float_button_markup(floating: @floating)
-        body_tag = interactive_tag
-
-        content_tag(:div, root_attributes(floating)) do
-          content_tag(body_tag, body_attributes(body_tag)) do
-            content_tag(:span, class: "hakumi-float-button-body") do
-              content_tag(:span, class: "hakumi-float-button-content") do
-                safe_join([
-                  icon_element,
-                  description_element,
-                  slot_content
-                ].compact)
-              end
-            end
-          end
-        end
-      end
-
-      def interactive_tag
-        @href.present? ? :a : :button
-      end
-
-      def icon_element
-        return nil unless @icon
-
-        icon_markup = if @icon.is_a?(String) || @icon.is_a?(Symbol)
-          render Hakumi::Icon::Component.new(name: @icon)
-        else
-          @icon
-        end
-
-        content_tag(:span, icon_markup, class: "hakumi-float-button-icon")
-      end
-
-      def description_element
-        return nil if @description.blank?
-
-        tag.span(@description, class: "hakumi-float-button-description")
-      end
-
-      def root_attributes(floating)
-        base_attrs = {
-          class: class_names(
-            "float-button",
-            {
-              circle: (@shape == :circle),
-              square: (@shape == :square),
-              primary: (@type == :primary),
-              danger: @danger,
-              static: !floating,
-              "with-description": @description.present?
-            }
-          ),
-          style: floating ? floating_style : nil
-        }
-
-        custom_style = @html_options[:style]
-        merged = merge_attributes(base_attrs, @html_options.except(:style))
-        merged[:style] = merge_styles(base_attrs[:style], custom_style)
-        merged
-      end
-
-      def body_attributes(tag_name)
-        attrs = {
-          class: "hakumi-float-button-button",
-          "aria-label": @tooltip || @description,
-          title: @tooltip
-        }
-
-        if tag_name == :button
-          attrs[:type] = "button"
-        else
-          attrs[:href] = @href
-          attrs[:target] = @target if @target
-          attrs[:role] = "button"
-          attrs[:rel] = "noopener noreferrer" if @target == "_blank"
-        end
-
-        custom_style = @button_options[:style]
-        merged = merge_attributes(attrs, @button_options.except(:style))
-        merged[:style] = merge_styles(nil, custom_style)
-        merged
-      end
-
-      def floating_style
-        return nil unless @floating
-
-        resolved = resolved_offset
-        styles = [ "position: fixed", "z-index: 1000" ]
-        resolved.each do |key, value|
-          styles << "#{key}: #{dimension(value)}"
-        end
-
-        styles.join("; ")
-      end
-
-      def resolved_offset
-        placement_offset = PLACEMENTS[@placement] || PLACEMENTS[:bottom_right]
-        custom_offset = @offset || {}
-        placement_offset.merge(custom_offset).compact
-      end
-
-      def dimension(value)
-        return value if value.is_a?(String)
-
-        "#{value}px"
-      end
-
-      def slot_content
-        content if content?
-      end
-
-      def validate_description_support!
-        return if @description.blank?
-        return if @shape == :square
-
-        raise ArgumentError, "description is only supported when shape is :square"
-      end
-
-      def wrap_with_badge(markup)
-        return markup unless @badge.present?
-
-        badge_options = @badge.is_a?(Hash) ? @badge.deep_dup : {}
-
-        if @floating
-          badge_options[:style] = merge_styles(badge_options[:style], floating_style)
-          button_markup = float_button_markup(floating: false)
-          render(Hakumi::Badge::Component.new(**badge_options)) { button_markup }
-        else
-          render(Hakumi::Badge::Component.new(**badge_options)) { markup }
-        end
-      end
-
-      def merge_styles(*styles)
-        styles.compact!
-        return nil if styles.empty?
-
-        styles.join("; ")
-      end
-    end
-  end
-end

data/app/components/hakumi/float_button/group/component.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module FloatButton
-    module Group
-      class Component < Hakumi::BaseComponent
-        SHAPES = Hakumi::FloatButton::Component::SHAPES
-        TYPES = Hakumi::FloatButton::Component::TYPES
-        TRIGGERS = [ :click, :hover ].freeze
-        EXPAND_DIRECTIONS = [ :top, :right, :bottom, :left ].freeze
-        PLACEMENTS = Hakumi::FloatButton::Component::PLACEMENTS
-
-        def initialize(
-          icon: :plus,
-          tooltip: nil,
-          shape: :circle,
-          type: :default,
-          trigger: :click,
-          open: nil,
-          default_open: false,
-          expand_direction: :top,
-          items: [],
-          floating: true,
-          placement: :bottom_right,
-          offset: nil,
-          button_options: {},
-          **html_options
-        )
-          @icon = icon
-          @tooltip = tooltip
-          @shape = shape
-          @type = type
-          @trigger = trigger
-          @open = open
-          @default_open = default_open
-          @expand_direction = expand_direction
-          @items = items
-          @floating = floating
-          @placement = placement
-          @offset = offset
-          @button_options = button_options
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def call
-          content_tag(:div, root_attributes) do
-            safe_join([
-              trigger_button,
-              actions_wrapper
-            ])
-          end
-        end
-
-        private
-
-        def validate_props!
-          validate_inclusion!(:shape, SHAPES)
-          validate_inclusion!(:type, TYPES)
-          validate_inclusion!(:trigger, TRIGGERS)
-          validate_inclusion!(:expand_direction, EXPAND_DIRECTIONS)
-          validate_inclusion!(:placement, PLACEMENTS.keys)
-        end
-
-        def root_attributes
-          base_attrs = {
-            class: class_names(
-              "float-button-group",
-              {
-                open: open_for_click?,
-                "trigger-hover": (@trigger == :hover),
-                "expand-#{@expand_direction}": true,
-                static: !@floating
-              }
-            ),
-            style: floating_style
-          }
-
-          merged = merge_attributes(base_attrs, @html_options.except(:data))
-          merged[:data] = base_attrs_data.merge(@html_options[:data] || {})
-          apply_controller_data!(merged[:data]) if use_controller?
-          merged
-        end
-
-        def base_attrs_data
-          {
-            trigger: @trigger,
-            "expand-direction": @expand_direction
-          }
-        end
-
-        def apply_controller_data!(data)
-          data[:controller] = append_controller(data[:controller], "hakumi--float-button-group")
-          data["hakumi--float-button-group-default-open-value"] = @default_open
-          data["hakumi--float-button-group-trigger-value"] = @trigger
-        end
-
-        def trigger_button
-          render Hakumi::FloatButton::Component.new(
-            icon: @icon,
-            tooltip: @tooltip,
-            shape: @shape,
-            type: @type,
-            floating: false,
-            placement: :bottom_right,
-            button_options: trigger_button_options,
-            **{ class: "hakumi-float-button-group-trigger" }
-          )
-        end
-
-        def trigger_button_options
-          options = @button_options.deep_dup
-          return options unless attach_click_action?
-
-          data = options[:data] || {}
-          data[:action] = append_action(data[:action], "click->hakumi--float-button-group#toggle")
-          options[:data] = data
-          options
-        end
-
-        def actions_wrapper
-          content_tag(:div, actions_attributes) do
-            actions_content
-          end
-        end
-
-        def actions_attributes
-          attrs = {
-            class: class_names(
-              "float-button-group-actions",
-              {
-                open: open_for_click?,
-                "has-content": content?,
-                "expand-#{@expand_direction}": true
-              }
-            )
-          }
-
-          attrs[:data] = {
-            "hakumi--float-button-group-target": "actions"
-          } if use_controller?
-
-          attrs
-        end
-
-        def actions_content
-          return content if content?
-
-          safe_join(@items.map { |item| render_item(item) })
-        end
-
-        def render_item(item)
-          item_options = item.deep_symbolize_keys
-          item_html_options = item_options.delete(:html_options) { {} }
-
-          component_options = {
-            shape: @shape,
-            type: item_options[:type] || @type,
-            floating: false,
-            placement: :bottom_right
-          }.merge(item_options)
-
-          merged_html_options = { class: "hakumi-float-button-group-item" }.merge(item_html_options)
-
-          render Hakumi::FloatButton::Component.new(**component_options, **merged_html_options)
-        end
-
-        def floating_style
-          return nil unless @floating
-
-          resolved = resolved_offset
-          styles = [ "position: fixed", "z-index: 1000" ]
-          resolved.each do |key, value|
-            styles << "#{key}: #{dimension(value)}"
-          end
-
-          styles.join("; ")
-        end
-
-        def resolved_offset
-          placement_offset = PLACEMENTS[@placement] || PLACEMENTS[:bottom_right]
-          custom_offset = @offset || {}
-          placement_offset.merge(custom_offset).compact
-        end
-
-        def dimension(value)
-          return value if value.is_a?(String)
-
-          "#{value}px"
-        end
-
-        def open_state?
-          controlled? ? !!@open : @default_open
-        end
-
-        def controlled?
-          !@open.nil?
-        end
-
-        def use_controller?
-          (@trigger == :click && !controlled?) || (@trigger == :hover)
-        end
-
-        def attach_click_action?
-          @trigger == :click && !controlled?
-        end
-
-        def open_for_click?
-          @trigger == :click && open_state?
-        end
-
-        def append_controller(existing, name)
-          return name unless existing.present?
-
-          [ existing, name ].join(" ")
-        end
-
-        def append_action(existing, action)
-          return action unless existing.present?
-
-          [ existing, action ].join(" ")
-        end
-      end
-    end
-  end
-end