hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module AdminPanel
-    class Component < Hakumi::BaseComponent
-      def self.extract_controller_locals(params)
-        {
-          title: params[:title],
-          enabled: params[:enabled] != "false"
-        }.compact
-      end
-
-      def initialize(title: "Admin Panel", enabled: true, **html_options)
-        @title = title
-        @enabled = enabled
-        @html_options = html_options
-      end
-
-      def render?
-        @enabled
-      end
-
-      private
-
-      attr_reader :title
-
-      def wrapper_attributes
-        attrs = {
-          class: class_names("admin-panel", {}, [ @html_options[:class] ]),
-          data: {
-            controller: "hakumi--admin-panel",
-            'turbo-permanent': true
-          }
-        }
-
-        merge_attributes(attrs, @html_options.except(:class))
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Affix
-    class Component < Hakumi::BaseComponent
-      def self.extract_controller_locals(params)
-        {
-          body: params[:body],
-          offset_top: params[:offset_top]&.to_f,
-          offset_bottom: params[:offset_bottom]&.to_f,
-          target_selector: params[:target_selector],
-          z_index: params[:z_index]&.to_i,
-          on_change: params[:on_change]
-        }
-      end
-
-      def initialize(
-        body: nil,
-        offset_top: nil,
-        offset_bottom: nil,
-        target_selector: nil,
-        z_index: nil,
-        on_change: nil,
-        **html_options
-      )
-        @body = body
-        @offset_top = normalize_numeric(offset_top)
-        @offset_bottom = normalize_numeric(offset_bottom)
-        @target_selector = target_selector
-        @z_index = normalize_numeric(z_index)&.to_i
-        @on_change = on_change
-        @html_options = html_options
-
-        normalize_offsets!
-        validate_props!
-      end
-
-      def root_attributes
-        base_attrs = {
-          class: class_names("affix"),
-          data: data_attributes
-        }
-
-        merge_attributes(base_attrs, @html_options)
-      end
-
-      def content_value
-        content.presence || @body
-      end
-
-      private
-
-      def data_attributes
-        data = { controller: "hakumi--affix" }
-        data[:"hakumi--affix-offset-top-value"] = @offset_top unless @offset_top.nil?
-        data[:"hakumi--affix-offset-bottom-value"] = @offset_bottom unless @offset_bottom.nil?
-        data[:"hakumi--affix-target-selector-value"] = @target_selector if @target_selector.present?
-        data[:"hakumi--affix-z-index-value"] = @z_index unless @z_index.nil?
-        data[:action] = append_action(data[:action], "hakumi--affix:change->#{@on_change}") if @on_change.present?
-        data
-      end
-
-      def normalize_numeric(value)
-        return value unless value.is_a?(String)
-
-        return nil if value.strip.empty?
-
-        value.to_f
-      end
-
-      def normalize_offsets!
-        @offset_top = 0 if @offset_top.nil? && @offset_bottom.nil?
-      end
-
-      def validate_props!
-        return if @offset_top.nil? || @offset_bottom.nil?
-
-        raise ArgumentError, "offset_top and offset_bottom cannot be used together"
-      end
-
-      def append_action(existing, action)
-        return action if existing.blank?
-
-        [ existing, action ].join(" ")
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Alert
-    class Component < Hakumi::BaseComponent
-      TYPES = [ :success, :info, :warning, :error ].freeze
-
-      # Slots for content
-      renders_one :icon
-      renders_one :message
-      renders_one :description
-      renders_one :action
-      renders_one :close_icon
-
-      def initialize(
-        type: nil,
-        show_icon: nil,
-        closable: false,
-        banner: false,
-        **html_options
-      )
-        @type = type || :info
-        @show_icon = show_icon.nil? ? banner : show_icon
-        @closable = closable
-        @banner = banner
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:type, TYPES)
-      end
-
-      def wrapper_classes
-        classes = [ "hakumi-alert" ]
-        classes << "hakumi-alert-#{@type}" if @type
-        classes << "hakumi-alert-with-description" if description?
-        classes << "hakumi-alert-with-icon" if show_icon?
-        classes << "hakumi-alert-no-icon" unless show_icon?
-        classes << "hakumi-alert-closable" if @closable
-        classes << "hakumi-alert-banner" if @banner
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
-      end
-
-      def wrapper_attributes
-        data_attrs = { controller: "hakumi--alert" }
-
-        merge_attributes(
-          { class: wrapper_classes, data: data_attrs },
-          @html_options
-        )
-      end
-
-      # Content resolution: message slot > block content
-      def message_content
-        message? ? message : content
-      end
-
-      def show_icon?
-        @show_icon
-      end
-
-      def default_icon_element
-        return nil unless show_icon?
-
-        icon_name = default_icon_name
-        render Hakumi::Icon::Component.new(name: icon_name)
-      end
-
-      def default_icon_name
-        case @type
-        when :success then :check_circle
-        when :warning then :exclamation_circle
-        when :error then :close_circle
-        else :info_circle
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Anchor
-    class Component < Hakumi::BaseComponent
-      DIRECTIONS = %i[vertical horizontal].freeze
-
-      renders_many :links, ->(href:, title:, **options) do
-        Hakumi::Anchor::Link::Component.new(href: href, title: title, **options)
-      end
-
-      def initialize(
-        affix: true,
-        bounds: 5,
-        offset_top: 0,
-        target_offset: nil,
-        direction: :vertical,
-        replace: false,
-        **html_options
-      )
-        @affix = affix
-        @bounds = bounds
-        @offset_top = offset_top
-        @target_offset = target_offset
-        @direction = direction
-        @replace = replace
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def wrapper_classes
-        classes = [ "hakumi-anchor-wrapper" ]
-        classes << "hakumi-anchor-wrapper-fixed" if @affix
-        classes << "hakumi-anchor-wrapper-horizontal" if horizontal?
-        classes.join(" ")
-      end
-
-      def anchor_classes
-        classes = [ "hakumi-anchor" ]
-        classes << "hakumi-anchor-fixed" if @affix
-        classes.join(" ")
-      end
-
-      def stimulus_controller
-        "hakumi--anchor"
-      end
-
-      def stimulus_values
-        {
-          offset_top: @offset_top,
-          target_offset: @target_offset || @offset_top,
-          bounds: @bounds,
-          replace: @replace,
-          direction: @direction.to_s
-        }.compact
-      end
-
-      def wrapper_attributes
-        base_data = stimulus_values.transform_keys { |k| "#{stimulus_controller}-#{k.to_s.dasherize}-value" }
-        base_data[:controller] = stimulus_controller
-
-        merge_attributes(
-          { class: wrapper_classes, data: base_data },
-          @html_options
-        )
-      end
-
-      def horizontal?
-        @direction == :horizontal
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:direction, DIRECTIONS)
-      end
-    end
-  end
-end

data/app/components/hakumi/anchor/link/component.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Anchor
-    module Link
-      class Component < Hakumi::BaseComponent
-        renders_many :links, ->(href:, title:, **options) do
-          Hakumi::Anchor::Link::Component.new(href: href, title: title, **options)
-        end
-
-        def initialize(href:, title:, target: nil, **html_options)
-          @href = href
-          @title = title
-          @target = target
-          @html_options = html_options
-        end
-
-        attr_reader :href, :title, :target
-
-        def link_classes
-          "hakumi-anchor-link"
-        end
-
-        def title_classes
-          "hakumi-anchor-link-title"
-        end
-
-        def has_children?
-          links.any?
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-<div <%= tag.attributes(wrapper_attributes).to_s.html_safe %>>
-  <div class="hakumi-auto-complete-input-wrapper">
-    <% if custom_input_renderer? %>
-      <%= input_renderer.call(input_attributes) %>
-    <% else %>
-      <input <%= tag.attributes(input_attributes).to_s.html_safe %>>
-    <% end %>
-
-    <% if allow_clear? %>
-      <button
-        type="button"
-        class="hakumi-auto-complete-clear-icon"
-        aria-label="Clear"
-        data-hakumi--autocomplete-target="clear"
-        data-action="click->hakumi--autocomplete#clear">
-        <%= render Hakumi::Icon::Component.new(name: clear_icon, theme: :filled, fallback_to_outlined: true) %>
-      </button>
-    <% end %>
-  </div>
-
-  <template data-hakumi--autocomplete-target="optionTemplate">
-    <div
-      class="hakumi-auto-complete-item"
-      role="option"
-      data-hakumi--autocomplete-target="option"
-      data-action="mousedown->hakumi--autocomplete#select click->hakumi--autocomplete#select">
-      <span class="hakumi-auto-complete-item-label"></span>
-    </div>
-  </template>
-
-  <div
-    id="<%= dropdown_id %>"
-    class="hakumi-auto-complete-dropdown hakumi-auto-complete-dropdown-hidden"
-    role="listbox"
-    data-hakumi--autocomplete-target="dropdown">
-    <% if normalized_items.any? %>
-      <% normalized_items.each do |item| %>
-        <% if item[:type] == :group %>
-          <div class="hakumi-auto-complete-group">
-            <div class="hakumi-auto-complete-group-label"><%= item[:label] %></div>
-            <% item[:options].each do |opt| %>
-              <div
-                class="hakumi-auto-complete-item"
-                role="option"
-                data-value="<%= opt[:value] %>"
-                data-label="<%= opt[:label] %>"
-                data-hakumi--autocomplete-target="option"
-                data-action="mousedown->hakumi--autocomplete#select click->hakumi--autocomplete#select">
-                <span class="hakumi-auto-complete-item-label"><%= opt[:label] %></span>
-              </div>
-            <% end %>
-          </div>
-        <% elsif item && item[:type] == :option %>
-          <div
-            class="hakumi-auto-complete-item"
-            role="option"
-            data-value="<%= item[:value] %>"
-            data-label="<%= item[:label] %>"
-            data-hakumi--autocomplete-target="option"
-            data-action="mousedown->hakumi--autocomplete#select click->hakumi--autocomplete#select">
-            <span class="hakumi-auto-complete-item-label"><%= item[:label] %></span>
-          </div>
-        <% end %>
-      <% end %>
-    <% end %>
-
-    <div
-      class="hakumi-auto-complete-empty"
-      data-hakumi--autocomplete-target="empty"
-      style="display: <%= normalized_items.any? ? 'none' : 'block' %>;">
-      <%= not_found_content %>
-    </div>
-  </div>
-</div>

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

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Autocomplete
-    # Hakumi Autocomplete component
-    # Text input with dropdown suggestions, built on top of Ant Design styles.
-    class Component < Hakumi::BaseComponent
-      SIZES = %i[small middle large].freeze
-      VARIANTS = %i[outlined filled borderless underlined].freeze
-      STATUSES = %i[error warning].freeze
-      FILTER_MODES = %i[contains starts_with].freeze
-
-      # @param name [String, Symbol] input name/id
-      # @param options [Array] list of options or groups
-      #   - "label" (String) -> label & value are the same
-      #   - [label, value]
-      #   - { label:, value: }
-      #   - { label:, options: [...] } for grouped options
-      def initialize(
-        name:,
-        options: [],
-        value: nil,
-        placeholder: nil,
-        size: :middle,
-        variant: :outlined,
-        status: nil,
-        disabled: false,
-        allow_clear: false,
-        clear_icon: :close_circle,
-        input_renderer: nil,
-        case_sensitive: false,
-        filter_mode: :contains,
-        not_found_content: "No options",
-        **html_options
-      )
-        @name = name
-        @options = options
-        @value = value
-        @placeholder = placeholder
-        @size = size
-        @variant = variant
-        @status = status
-        @disabled = disabled
-        @allow_clear = allow_clear
-        @clear_icon = clear_icon
-        @input_renderer = input_renderer
-        @case_sensitive = case_sensitive
-        @filter_mode = filter_mode
-        @not_found_content = not_found_content
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZES)
-        validate_inclusion!(:variant, VARIANTS)
-        validate_inclusion!(:filter_mode, FILTER_MODES)
-        validate_inclusion!(:status, STATUSES) if @status
-      end
-
-      def wrapper_classes
-        class_names(
-          "auto-complete",
-          {
-            @size => (@size != :middle),
-            "status-error": @status == :error,
-            "status-warning": @status == :warning,
-            "varihakumi-outlined": @variant == :outlined,
-            "varihakumi-filled": @variant == :filled,
-            "varihakumi-borderless": @variant == :borderless,
-            "varihakumi-underlined": @variant == :underlined,
-            disabled: @disabled
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def wrapper_attributes
-        base_attrs = {
-          class: wrapper_classes,
-          data: {
-            controller: "hakumi--autocomplete",
-            "hakumi--autocomplete-case-sensitive-value": @case_sensitive ? "true" : "false",
-            "hakumi--autocomplete-filter-mode-value": @filter_mode.to_s
-          }
-        }
-
-        extra = @html_options.except(:class)
-        merge_attributes(base_attrs, extra)
-      end
-
-      def input_attributes
-        attrs = {
-          type: "text",
-          name: @name,
-          id: @html_options[:id] || @name,
-          value: @value,
-          placeholder: @placeholder,
-          disabled: (@disabled ? true : nil),
-          autocomplete: "off",
-          spellcheck: "false",
-          aria: {
-            autocomplete: "list",
-            controls: dropdown_id,
-            expanded: "false"
-          },
-          data: {
-            action: "input->hakumi--autocomplete#onInput keydown->hakumi--autocomplete#onKeydown focus->hakumi--autocomplete#open blur->hakumi--autocomplete#onBlur",
-            "hakumi--autocomplete-target": "input"
-          }
-        }
-
-        attrs[:class] = input_classes unless custom_input_renderer?
-        attrs[:aria].compact!
-        attrs
-      end
-
-      def input_classes
-        classes = [ "hakumi-input" ]
-        classes << "hakumi-input-#{@size}" if @size != :middle
-        classes.join(" ")
-      end
-
-      def dropdown_id
-        @dropdown_id ||= "#{@name}_autocomplete_dropdown"
-      end
-
-      def allow_clear?
-        @allow_clear
-      end
-
-      def custom_input_renderer?
-        @input_renderer.respond_to?(:call)
-      end
-
-      def input_renderer
-        @input_renderer
-      end
-
-      def disabled?
-        @disabled
-      end
-
-      def clear_icon
-        @clear_icon
-      end
-
-      def not_found_content
-        @not_found_content
-      end
-
-      def normalized_items
-        @normalized_items ||= begin
-          Array(@options).flat_map do |opt|
-            if opt.is_a?(Hash) && opt[:options]
-              {
-                type: :group,
-                label: opt[:label].to_s,
-                options: normalize_group_options(opt[:options])
-              }
-            else
-              normalize_simple_option(opt)
-            end
-          end
-        end
-      end
-
-      def normalize_group_options(options)
-        Array(options).map { |opt| normalize_simple_option(opt) }.compact
-      end
-
-      def normalize_simple_option(opt)
-        case opt
-        when nil
-          nil
-        when Hash
-          {
-            type: :option,
-            label: opt[:label].to_s,
-            value: (opt[:value] || opt[:label]).to_s
-          }
-        when Array
-          label, value = opt
-          {
-            type: :option,
-            label: label.to_s,
-            value: (value || label).to_s
-          }
-        else
-          {
-            type: :option,
-            label: opt.to_s,
-            value: opt.to_s
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Avatar
-    class Component < Hakumi::BaseComponent
-      SHAPES = [ :circle, :square ].freeze
-      SIZES = [ :small, :default, :large ].freeze
-
-      def initialize(
-        shape: :circle,
-        size: :default,
-        src: nil,
-        icon: nil,
-        alt: nil,
-        **html_options
-      )
-        @shape = shape
-        @size = size
-        @src = src
-        @icon = icon
-        @alt = alt
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def call
-        content_tag(:span, content_wrapper, wrapper_attributes)
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:shape, SHAPES)
-        validate_inclusion!(:size, SIZES) unless @size.is_a?(Integer)
-      end
-
-      def wrapper_classes
-        class_names(
-          "avatar",
-          {
-            @shape => true,
-            lg: @size == :large,
-            sm: @size == :small,
-            icon: @icon.present?,
-            image: @src.present?
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def content_wrapper
-        if @src
-          image_tag(@src, alt: @alt, width: avatar_size, height: avatar_size)
-        elsif @icon
-          # Pass size: nil to allow icon to inherit font-size from avatar
-          render Hakumi::Icon::Component.new(name: @icon, size: nil)
-        else
-          tag.span(content, data: { hakumi__avatar_text_target: "text" })
-        end
-      end
-
-      def avatar_size
-        case @size
-        when :large then 40
-        when :small then 24
-        when Integer then @size
-        else 32
-        end
-      end
-
-      def wrapper_attributes
-        attrs = {
-          class: wrapper_classes
-        }
-
-        if @size.is_a?(Integer)
-          attrs[:style] = "width: #{@size}px; height: #{@size}px; font-size: #{@size / 2}px;"
-        end
-
-        # Add controller for text avatars
-        unless @src || @icon
-          attrs[:data] ||= {}
-          attrs[:data][:controller] = "hakumi--avatar-text"
-        end
-
-        merge_attributes(attrs, @html_options.except(:class))
-      end
-    end
-  end
-end