hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/layout/footer/component.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Layout
+    module Footer
+      class Component < BaseComponent
+        extend T::Sig
+
+        sig { params(html_options: Types::HtmlAttributeValue).void }
+        def initialize(**html_options)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        private
+
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("layout-footer", {}, @html_options)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/layout/header/component.html.erb

@@ -0,0 +1 @@
+<%= content_tag :header, content, wrapper_attributes %>

data/app/components/hakumi_components/layout/header/component.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Layout
+    module Header
+      class Component < BaseComponent
+        extend T::Sig
+
+        sig { params(html_options: Types::HtmlAttributeValue).void }
+        def initialize(**html_options)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        private
+
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("layout-header", {}, @html_options)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/layout/sider/component.html.erb

@@ -0,0 +1 @@
+<%= content_tag :aside, content, wrapper_attributes %>

data/app/components/hakumi_components/layout/sider/component.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Layout
+    module Sider
+      class Component < BaseComponent
+        extend T::Sig
+        THEMES = T.let(%i[dark light].freeze, T::Array[Symbol])
+        BREAKPOINTS = T.let(%i[xs sm md lg xl].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            width: Integer,
+            collapsed_width: Integer,
+            collapsible: T::Boolean,
+            collapsed: T::Boolean,
+            theme: Symbol,
+            breakpoint: T.nilable(Symbol),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          width: 200,
+          collapsed_width: 80,
+          collapsible: false,
+          collapsed: false,
+          theme: :dark,
+          breakpoint: nil,
+          **html_options
+        )
+          @width = T.let(width, Integer)
+          @collapsed_width = T.let(collapsed_width, Integer)
+          @collapsible = T.let(collapsible, T::Boolean)
+          @collapsed = T.let(collapsed, T::Boolean)
+          @theme = T.let(theme, Symbol)
+          @breakpoint = T.let(breakpoint, T.nilable(Symbol))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+
+          validate_props!
+        end
+
+        private
+
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:theme, THEMES)
+          validate_inclusion!(:breakpoint, BREAKPOINTS) if @breakpoint
+        end
+
+        sig { returns(String) }
+        def wrapper_classes
+          modifiers = T.let({
+            dark: @theme == :dark,
+            light: @theme == :light,
+            collapsed: @collapsed,
+            "has-trigger": @collapsible
+          }, Types::ClassModifiers)
+          modifiers[@breakpoint] = true if @breakpoint
+
+          component_classes("layout-sider", modifiers, @html_options)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes(
+            { class: wrapper_classes, style: inline_styles },
+            @html_options.except(:class, :style)
+          )
+        end
+
+        sig { returns(String) }
+        def inline_styles
+          active_width = @collapsed ? @collapsed_width : @width
+          styles = T.let([
+            "flex: 0 0 #{active_width}px",
+            "max-width: #{active_width}px",
+            "min-width: #{active_width}px",
+            "width: #{active_width}px"
+          ], T::Array[String])
+
+          existing_style = html_style(@html_options)
+          styles << existing_style if existing_style
+
+          styles.join("; ")
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/mentions/coercion.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Mentions
+    module Coercion
+      extend T::Sig
+      extend self
+
+      OptionHash = T.type_alias do
+        T::Hash[T.any(Symbol, String), T.nilable(T.any(String, Symbol, Numeric))]
+      end
+      OptionTuple = T.type_alias { [ T.nilable(T.any(String, Symbol, Numeric)), T.nilable(T.any(String, Symbol, Numeric)) ] }
+      OptionInput = T.type_alias { T.any(HakumiComponents::Mentions::Option, OptionHash, OptionTuple, String, Symbol, Numeric) }
+
+      sig { params(options: T::Array[OptionInput]).returns(T::Array[HakumiComponents::Mentions::Option]) }
+      def options(options)
+        options.filter_map { |option| normalize_option(option) }
+      end
+
+      private
+
+      sig { params(option: OptionInput).returns(T.nilable(HakumiComponents::Mentions::Option)) }
+      def normalize_option(option)
+        return option if option.is_a?(HakumiComponents::Mentions::Option)
+
+        case option
+        when Hash
+          label = option[:label] || option["label"]
+          value = option[:value] || option["value"] || label
+          return nil if label.nil?
+
+          HakumiComponents::Mentions::Option.new(label: label.to_s, value: value.to_s)
+        when Array
+          label = option[0]
+          value = option[1] || label
+          return nil if label.nil?
+
+          HakumiComponents::Mentions::Option.new(label: label.to_s, value: value.to_s)
+        else
+          HakumiComponents::Mentions::Option.new(label: option.to_s, value: option.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,9 @@
 <% mentions_control = capture do %>
   <div <%= tag.attributes(wrapper_attributes).to_s.html_safe %>>
     <% if single_line? %>
-      <%= tag.input(type: :text, value: @value, **field_attributes) %>
+      <%= tag.input(type: :text, value: input_control_value, **field_attributes) %>
     <% else %>
-      <%= content_tag(:textarea, @value, **field_attributes) %>
+      <%= content_tag(:textarea, input_control_value, **field_attributes) %>
     <% end %>
 
     <div
@@ -14,11 +14,11 @@
         <button
           type="button"
           class="hakumi-mentions-option"
-          data-value="<%= option[:value] %>"
-          data-label="<%= option[:label] %>"
+          data-value="<%= option.value %>"
+          data-label="<%= option.label %>"
           data-action="mousedown->hakumi--mentions#select click->hakumi--mentions#select"
           data-hakumi--mentions-target="option">
-          <span class="hakumi-mentions-option-label"><%= option[:label] %></span>
+          <span class="hakumi-mentions-option-label"><%= option.label %></span>
         </button>
       <% end %>
 
@@ -32,7 +32,7 @@
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= mentions_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>

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

@@ -0,0 +1,229 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Mentions
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include HakumiComponents::Concerns::InputControl
+
+      OptionInput = T.type_alias { HakumiComponents::Mentions::Coercion::OptionInput }
+      MentionPrefix = T.type_alias { T.any(Types::StringOrSymbol, Types::StringOrSymbolArray) }
+
+      STATUSES = T.let([ nil, :error, :warning ].freeze, T::Array[T.nilable(Symbol)])
+      VARIANTS = T.let(%i[outlined borderless filled].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          default_value: Types::FormFieldValue,
+          options: T::Array[OptionInput],
+          prefix: MentionPrefix,
+          split: String,
+          filter_option: T.nilable(Types::StringOrSymbol),
+          placeholder: T.nilable(String),
+          disabled: T::Boolean,
+          readonly: T::Boolean,
+          required: T::Boolean,
+          rows: T.nilable(Integer),
+          auto_size: T::Boolean,
+          size: Symbol,
+          variant: Symbol,
+          status: T.nilable(Symbol),
+          standalone: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        name:,
+        label: nil,
+        caption: nil,
+        value: nil,
+        default_value: nil,
+        options: [],
+        prefix: "@",
+        split: " ",
+        filter_option: :contains,
+        placeholder: nil,
+        disabled: false,
+        readonly: false,
+        required: false,
+        rows: nil,
+        auto_size: false,
+        size: :default,
+        variant: :outlined,
+        status: nil,
+        standalone: true,
+        errors: [],
+        **html_options
+      )
+        @name = T.let(name, Types::FormFieldName)
+        @label = label
+        @caption = caption
+        @value = T.let(value.nil? ? default_value : value, Types::FormFieldValue)
+        @default_value = T.let(default_value, Types::FormFieldValue)
+        @options = T.let(HakumiComponents::Mentions::Coercion.options(options), T::Array[HakumiComponents::Mentions::Option])
+        @prefix = T.let(prefix, MentionPrefix)
+        @split = split
+        @filter_option = filter_option
+        @placeholder = placeholder
+        @disabled = disabled
+        @readonly = readonly
+        @required = required
+        @rows = rows
+        @auto_size = auto_size
+        @size = size
+        @variant = variant
+        @status = status
+        @standalone = standalone
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_input_control_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          value: @value,
+          placeholder: @placeholder,
+          size: @size,
+          disabled: @disabled,
+          readonly: @readonly,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options
+        )
+
+        validate_props!
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:variant, VARIANTS)
+        validate_inclusion!(:status, STATUSES) if @status
+      end
+
+      sig { returns(T::Boolean) }
+      def single_line?
+        @rows.nil? || @rows == 1
+      end
+
+      sig { returns(T::Boolean) }
+      def multiline?
+        !single_line?
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        class_names(
+          "mentions",
+          {
+            disabled: input_control_disabled,
+            readonly: input_control_readonly,
+            single: single_line?,
+            sm: single_line? && input_control_size == :small,
+            lg: single_line? && input_control_size == :large,
+            "variant-borderless": @variant == :borderless,
+            "variant-filled": @variant == :filled,
+            "status-error": @status == :error || error?,
+            "status-warning": @status == :warning
+          },
+          [ html_class_name ]
+        )
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        base_attrs = {
+          class: wrapper_classes,
+          data: {
+            controller: "hakumi--mentions",
+            hakumi__mentions_options_value: normalized_options.map(&:to_h).to_json,
+            hakumi__mentions_prefix_value: prefix_values.to_json,
+            hakumi__mentions_split_value: @split,
+            hakumi__mentions_filter_option_value: filter_option_value,
+            hakumi__mentions_disabled_value: input_control_disabled,
+            hakumi__mentions_readonly_value: input_control_readonly,
+            hakumi__mentions_auto_size_value: @auto_size
+          }
+        }
+
+        merge_attributes(base_attrs, form_field_html_options.except(:class))
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def field_attributes
+        attrs = T.let({
+          name: form_field_name,
+          id: input_id,
+          class: field_classes,
+          placeholder: input_control_placeholder,
+          disabled: input_control_disabled ? true : nil,
+          readonly: input_control_readonly ? true : nil,
+          "aria-invalid": error? ? "true" : nil,
+          "aria-describedby": describedby_ids,
+          data: field_data_attributes
+        }.compact, Types::HtmlAttributes)
+
+        attrs[:rows] = effective_rows if multiline?
+        attrs
+      end
+
+      sig { returns(String) }
+      def field_classes
+        "hakumi-mentions-input hakumi-input"
+      end
+
+      sig { returns(T::Array[HakumiComponents::Mentions::Option]) }
+      def normalized_options
+        @options
+      end
+
+      sig { returns(String) }
+      def filter_option_value
+        @filter_option.nil? ? "contains" : @filter_option.to_s
+      end
+
+      sig { returns(T::Array[String]) }
+      def prefix_values
+        values = @prefix.is_a?(Array) ? @prefix : [ @prefix ]
+        values.map(&:to_s)
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def field_data_attributes
+        action = T.let([
+          "input->hakumi--mentions#handleInput",
+          "keydown->hakumi--mentions#handleKeydown",
+          "focus->hakumi--mentions#handleFocus",
+          "blur->hakumi--mentions#handleBlur"
+        ], T::Array[String])
+        action << "scroll->hakumi--mentions#handleScroll" if multiline?
+
+        {
+          action: action.join(" "),
+          "hakumi--mentions-target": single_line? ? "input" : "textarea"
+        }
+      end
+
+      sig { returns(Integer) }
+      def effective_rows
+        rows = @rows
+        rows.nil? ? 3 : rows
+      end
+
+      sig { returns(T.nilable(String)) }
+      def html_class_name
+        css_class = form_field_html_options[:class]
+        css_class.is_a?(String) ? css_class : nil
+      end
+    end
+  end
+end

data/app/components/hakumi_components/mentions/option.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Mentions
+    class Option
+      extend T::Sig
+
+      sig { params(label: String, value: String).void }
+      def initialize(label:, value:)
+        @label = label
+        @value = value
+      end
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { returns(T::Hash[Symbol, String]) }
+      def to_h
+        {
+          label: @label,
+          value: @value
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Menu
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      MODES = T.let(%i[horizontal vertical inline].freeze, T::Array[Symbol])
+      TRIGGER_SUBMENU_ACTIONS = T.let(%i[hover click].freeze, T::Array[Symbol])
+
+      renders_many :items, types: {
+        item: {
+          renders: HakumiComponents::Menu::Item::Component,
+          as: :item
+        },
+        submenu: {
+          renders: ->(key:, label: nil, icon: nil, disabled: false) do
+            T.bind(self, HakumiComponents::Menu::Component)
+            HakumiComponents::Menu::SubMenu::Component.new(
+              key: key,
+              label: label,
+              icon: icon,
+              disabled: disabled,
+              mode: mode
+            )
+          end,
+          as: :submenu
+        },
+        group: {
+          renders: HakumiComponents::Menu::Group::Component,
+          as: :group
+        },
+        divider: {
+          renders: -> { HakumiComponents::Menu::Divider::Component.new },
+          as: :divider
+        }
+      }
+
+      sig do
+        params(
+          mode: Symbol,
+          selectable: T::Boolean,
+          multiple: T::Boolean,
+          inline_collapsed: T::Boolean,
+          inline_indent: Integer,
+          default_selected_keys: Types::StringOrSymbolArray,
+          default_open_keys: Types::StringOrSymbolArray,
+          trigger_submenu_action: Symbol,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        mode: :vertical,
+        selectable: true,
+        multiple: false,
+        inline_collapsed: false,
+        inline_indent: 24,
+        default_selected_keys: [],
+        default_open_keys: [],
+        trigger_submenu_action: :hover,
+        **html_options
+      )
+        @mode = T.let(mode, Symbol)
+        @selectable = T.let(selectable, T::Boolean)
+        @multiple = T.let(multiple, T::Boolean)
+        @inline_collapsed = T.let(inline_collapsed, T::Boolean)
+        @inline_indent = T.let(inline_indent, Integer)
+        @default_selected_keys = T.let(Array(default_selected_keys), Types::StringOrSymbolArray)
+        @default_open_keys = T.let(Array(default_open_keys), Types::StringOrSymbolArray)
+        @trigger_submenu_action = T.let(trigger_submenu_action, Symbol)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(Symbol) }
+      attr_reader :mode
+
+      sig { returns(Integer) }
+      attr_reader :inline_indent
+
+      sig { returns(String) }
+      def menu_classes
+        modifiers = T.let({
+          root: true,
+          @mode => true,
+          "inline-collapsed": @inline_collapsed && @mode == :inline
+        }, Types::ClassModifiers)
+        class_names("menu", modifiers)
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        data = stimulus_attrs("hakumi--menu", T.let({
+          mode: @mode.to_s,
+          selectable: @selectable,
+          multiple: @multiple,
+          inline_collapsed: @inline_collapsed,
+          inline_indent: @inline_indent,
+          default_selected_keys: @default_selected_keys.to_json,
+          default_open_keys: @default_open_keys.to_json,
+          trigger_submenu_action: @trigger_submenu_action.to_s
+        }, Types::StimulusValues))
+        merge_attributes({ class: menu_classes, role: "menu", data: data }, @html_options)
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:mode, MODES)
+        validate_inclusion!(:trigger_submenu_action, TRIGGER_SUBMENU_ACTIONS)
+      end
+    end
+  end
+end

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

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

data/app/components/hakumi_components/menu/group/component.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Menu
+    module Group
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        renders_many :items, types: {
+          item: {
+            renders: HakumiComponents::Menu::Item::Component,
+            as: :item
+          }
+        }
+
+        sig do
+          params(
+            label: String,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(label:, **html_options)
+          @label = T.let(label, String)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(String) }
+        attr_reader :label
+
+        sig { returns(String) }
+        def group_classes
+          "hakumi-menu-item-group"
+        end
+
+        sig { returns(String) }
+        def title_classes
+          "hakumi-menu-item-group-title"
+        end
+
+        sig { returns(String) }
+        def list_classes
+          "hakumi-menu-item-group-list"
+        end
+      end
+    end
+  end
+end