hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/transfer/component.html.erb

@@ -0,0 +1,204 @@
+<% transfer_control = capture do %>
+  <div <%= tag.attributes(wrapper_attributes) %>>
+    <div class="hakumi-transfer-panel hakumi-transfer-panel-source">
+      <div class="hakumi-transfer-header">
+        <% if show_select_all? %>
+          <label class="hakumi-checkbox-wrapper hakumi-transfer-select-all">
+            <span class="hakumi-checkbox" data-hakumi--transfer-target="sourceSelectAllWrapper">
+              <input
+                type="checkbox"
+                class="hakumi-checkbox-input"
+                data-hakumi--transfer-target="sourceSelectAll"
+                data-action="change->hakumi--transfer#toggleSelectAll"
+                data-hakumi--transfer-list-param="source"
+                <%= "disabled" if disabled? %>>
+              <span class="hakumi-checkbox-inner"></span>
+            </span>
+          </label>
+        <% end %>
+        <span class="hakumi-transfer-header-title">
+          <span class="hakumi-transfer-title"><%= titles[0] %></span>
+          <span class="hakumi-transfer-count" data-hakumi--transfer-target="sourceCount"></span>
+        </span>
+      </div>
+
+      <% if show_search? %>
+        <div class="hakumi-transfer-search">
+          <span class="hakumi-transfer-search-icon">
+            <%= render HakumiComponents::Icon::Component.new(name: :search) %>
+          </span>
+          <input
+            type="search"
+            class="hakumi-transfer-search-input"
+            placeholder="<%= search_placeholder %>"
+            data-hakumi--transfer-target="sourceSearch"
+            data-action="input->hakumi--transfer#filterList"
+            data-hakumi--transfer-list-param="source"
+            <%= "disabled" if disabled? %>>
+        </div>
+      <% end %>
+
+      <ul class="hakumi-transfer-list" data-hakumi--transfer-target="sourceList">
+        <% source_items.each_with_index do |item, index| %>
+          <li
+            class="<%= item_classes(item) %>"
+            data-key="<%= item.key %>"
+            data-disabled="<%= item.disabled ? "true" : "false" %>">
+            <input
+              type="hidden"
+              name="<%= hidden_input_name %>"
+              value="<%= item.key %>"
+              data-hakumi--transfer-hidden-input="true"
+              disabled>
+            <label class="hakumi-checkbox-wrapper hakumi-transfer-item">
+              <span class="hakumi-checkbox<%= " hakumi-checkbox-disabled" if disabled? || item.disabled %>">
+                <input
+                  type="checkbox"
+                  class="hakumi-checkbox-input"
+                  id="<%= item_checkbox_id(item, :source, index) %>"
+                  name="<%= "#{form_field_name}_source" %>"
+                  data-action="change->hakumi--transfer#toggleSelection"
+                  data-hakumi--transfer-list-param="source"
+                  data-hakumi--transfer-target="sourceCheckbox"
+                  <%= "disabled" if disabled? || item.disabled %>>
+                <span class="hakumi-checkbox-inner"></span>
+              </span>
+              <span class="hakumi-transfer-item-content">
+                <span class="hakumi-transfer-item-title"><%= item_content(item) %></span>
+                <% if (description = item_description(item)) %>
+                  <span class="hakumi-transfer-item-description"><%= description %></span>
+                <% end %>
+              </span>
+            </label>
+          </li>
+        <% end %>
+      </ul>
+
+      <% if pagination? %>
+        <div class="hakumi-transfer-pagination" data-hakumi--transfer-target="sourcePagination"></div>
+      <% end %>
+    </div>
+
+    <div class="hakumi-transfer-controls" data-hakumi--transfer-target="controls">
+      <button
+        type="button"
+        class="hakumi-transfer-control"
+        data-hakumi--transfer-target="moveToTarget"
+        data-action="click->hakumi--transfer#moveToTarget"
+        <%= "disabled" if disabled? %>>
+        <span class="hakumi-transfer-control-icon">
+          <%= render HakumiComponents::Icon::Component.new(name: operations.to_target) %>
+        </span>
+      </button>
+
+      <% unless one_way? %>
+        <button
+          type="button"
+          class="hakumi-transfer-control"
+          data-hakumi--transfer-target="moveToSource"
+          data-action="click->hakumi--transfer#moveToSource"
+          <%= "disabled" if disabled? %>>
+          <span class="hakumi-transfer-control-icon">
+            <%= render HakumiComponents::Icon::Component.new(name: operations.to_source) %>
+          </span>
+        </button>
+      <% end %>
+    </div>
+
+    <div class="hakumi-transfer-panel hakumi-transfer-panel-target">
+      <div class="hakumi-transfer-header">
+        <% if show_select_all? %>
+          <label class="hakumi-checkbox-wrapper hakumi-transfer-select-all">
+            <span class="hakumi-checkbox" data-hakumi--transfer-target="targetSelectAllWrapper">
+              <input
+                type="checkbox"
+                class="hakumi-checkbox-input"
+                data-hakumi--transfer-target="targetSelectAll"
+                data-action="change->hakumi--transfer#toggleSelectAll"
+                data-hakumi--transfer-list-param="target"
+                <%= "disabled" if disabled? %>>
+              <span class="hakumi-checkbox-inner"></span>
+            </span>
+          </label>
+        <% end %>
+        <span class="hakumi-transfer-header-title">
+          <span class="hakumi-transfer-title"><%= titles[1] %></span>
+          <span class="hakumi-transfer-count" data-hakumi--transfer-target="targetCount"></span>
+        </span>
+      </div>
+
+      <% if show_search? %>
+        <div class="hakumi-transfer-search">
+          <span class="hakumi-transfer-search-icon">
+            <%= render HakumiComponents::Icon::Component.new(name: :search) %>
+          </span>
+          <input
+            type="search"
+            class="hakumi-transfer-search-input"
+            placeholder="<%= search_placeholder %>"
+            data-hakumi--transfer-target="targetSearch"
+            data-action="input->hakumi--transfer#filterList"
+            data-hakumi--transfer-list-param="target"
+            <%= "disabled" if disabled? %>>
+        </div>
+      <% end %>
+
+      <ul class="hakumi-transfer-list" data-hakumi--transfer-target="targetList">
+        <% target_items.each_with_index do |item, index| %>
+          <li
+            class="<%= item_classes(item) %>"
+            data-key="<%= item.key %>"
+            data-disabled="<%= item.disabled ? "true" : "false" %>">
+            <input
+              type="hidden"
+              name="<%= hidden_input_name %>"
+              value="<%= item.key %>"
+              data-hakumi--transfer-hidden-input="true">
+            <label class="hakumi-checkbox-wrapper hakumi-transfer-item">
+              <span class="hakumi-checkbox<%= " hakumi-checkbox-disabled" if disabled? || item.disabled %>">
+                <input
+                  type="checkbox"
+                  class="hakumi-checkbox-input"
+                  id="<%= item_checkbox_id(item, :target, index) %>"
+                  name="<%= "#{form_field_name}_target" %>"
+                  data-action="change->hakumi--transfer#toggleSelection"
+                  data-hakumi--transfer-list-param="target"
+                  data-hakumi--transfer-target="targetCheckbox"
+                  <%= "disabled" if disabled? || item.disabled %>>
+                <span class="hakumi-checkbox-inner"></span>
+              </span>
+              <span class="hakumi-transfer-item-content">
+                <span class="hakumi-transfer-item-title"><%= item_content(item) %></span>
+                <% if (description = item_description(item)) %>
+                  <span class="hakumi-transfer-item-description"><%= description %></span>
+                <% end %>
+              </span>
+            </label>
+          </li>
+        <% end %>
+      </ul>
+
+      <% if pagination? %>
+        <div class="hakumi-transfer-pagination" data-hakumi--transfer-target="targetPagination"></div>
+      <% end %>
+    </div>
+  </div>
+<% end %>
+
+<% if standalone? %>
+  <%= transfer_control %>
+<% else %>
+  <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>
+    <%= render_label %>
+
+    <div class="hakumi-form-item-control">
+      <div class="hakumi-form-item-control-input">
+        <div class="hakumi-form-item-control-input-content">
+          <%= transfer_control %>
+        </div>
+      </div>
+
+      <%= render_explain %>
+    </div>
+  </div>
+<% end %>

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

@@ -0,0 +1,395 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Transfer
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+      include HakumiComponents::Concerns::FormField
+
+      ItemInput = T.type_alias { HakumiComponents::Transfer::Coercion::ItemInput }
+      PaginationHash = T.type_alias do
+        T::Hash[Types::HtmlKey, Types::HtmlPrimitive]
+      end
+      OperationsHash = T.type_alias do
+        T::Hash[Types::HtmlKey, T.nilable(Types::HtmlKey)]
+      end
+      ControllerScalar = T.type_alias { T.nilable(Types::ValidationPrimitive) }
+      StringArrayValue = T.type_alias { T::Array[String] }
+      ItemArrayValue = T.type_alias { T::Array[ItemInput] }
+      PaginationScalar = T.type_alias { T.any(String, T::Boolean) }
+      PaginationInput = T.type_alias { T.nilable(T.any(PaginationScalar, PaginationHash)) }
+      PaginationValue = T.type_alias { T.nilable(T.any(T::Boolean, PaginationHash)) }
+      ControllerCollection = T.type_alias { T.any(StringArrayValue, ItemArrayValue, PaginationHash) }
+      ControllerParam = T.type_alias { T.nilable(T.any(ControllerScalar, ControllerCollection)) }
+      ControllerLocalValue = T.type_alias { T.nilable(T.any(ControllerScalar, ControllerCollection)) }
+      ControllerLocals = T.type_alias { T::Hash[Symbol, ControllerLocalValue] }
+      PaginationDataValue = T.type_alias { Types::HtmlPrimitive }
+      StringOrItemsInput = T.type_alias { T.nilable(T.any(String, ItemArrayValue)) }
+      StringOrStringsInput = T.type_alias { T.nilable(T.any(String, StringArrayValue)) }
+      RenderItem = T.type_alias do
+        T.nilable(T.any(
+          T.proc.params(item: HakumiComponents::Transfer::Item).returns(Types::Renderable),
+          Types::ComponentRenderable
+        ))
+      end
+
+      sig { params(params: T::Hash[Symbol, ControllerParam]).returns(ControllerLocals) }
+      def self.extract_controller_locals(params)
+        {
+          data_source: parse_data_source(data_source_param(params[:data_source])),
+          target_keys: parse_json_array(string_array_param(params[:target_keys])),
+          titles: parse_json_array(string_array_param(params[:titles])),
+          disabled: boolean_param(boolean_param_input(params[:disabled])),
+          show_search: boolean_param(boolean_param_input(params[:show_search])),
+          show_select_all: boolean_param(boolean_param_input(params[:show_select_all]), default: true),
+          one_way: boolean_param(boolean_param_input(params[:one_way])),
+          pagination: parse_pagination(pagination_param(params[:pagination])),
+          name: params[:name]
+        }.compact
+      end
+
+      sig do
+        params(
+          data_source: T::Array[ItemInput],
+          target_keys: T.nilable(T::Array[HakumiComponents::Types::FormFieldScalar]),
+          name: T.nilable(Types::FormFieldName),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          titles: T.nilable(T::Array[String]),
+          disabled: T::Boolean,
+          required: T::Boolean,
+          show_search: T::Boolean,
+          show_select_all: T::Boolean,
+          one_way: T::Boolean,
+          pagination: PaginationValue,
+          standalone: T::Boolean,
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          render_item: RenderItem,
+          operations: T.nilable(OperationsHash),
+          search_placeholder: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        data_source:,
+        target_keys: nil,
+        name: nil,
+        label: nil,
+        caption: nil,
+        value: nil,
+        titles: nil,
+        disabled: false,
+        required: false,
+        show_search: false,
+        show_select_all: true,
+        one_way: false,
+        pagination: false,
+        standalone: true,
+        rules: nil,
+        errors: [],
+        render_item: nil,
+        operations: nil,
+        search_placeholder: nil,
+        **html_options
+      )
+        @name = T.let(normalize_string(name) || generate_id("transfer"), Types::FormFieldName)
+        @label = label
+        @caption = caption
+        @value = T.let(value, Types::FormFieldValue)
+        @disabled = T.let(cast_boolean(disabled) == true, T::Boolean)
+        @required = T.let(cast_boolean(required) == true, T::Boolean)
+        @standalone = T.let(cast_boolean(standalone) != false, T::Boolean)
+        @rules = T.let(rules, T.nilable(T::Array[Types::ValidationRule]))
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @data_source = T.let(HakumiComponents::Transfer::Coercion.items(data_source, disabled: @disabled), T::Array[HakumiComponents::Transfer::Item])
+        @target_keys = T.let(normalize_target_keys(target_keys, value), T::Array[String])
+        @titles = T.let(normalize_titles(titles), [ String, String ])
+        @show_search = T.let(cast_boolean(show_search) == true, T::Boolean)
+        @show_select_all = T.let(cast_boolean(show_select_all) != false, T::Boolean)
+        @one_way = T.let(cast_boolean(one_way) == true, T::Boolean)
+        @pagination = T.let(pagination, PaginationValue)
+        @render_item = T.let(render_item, RenderItem)
+        @operations = T.let(normalize_operations(operations), HakumiComponents::Transfer::Operations)
+        @search_placeholder = search_placeholder
+        @source_items = T.let(nil, T.nilable(T::Array[HakumiComponents::Transfer::Item]))
+        @target_items = T.let(nil, T.nilable(T::Array[HakumiComponents::Transfer::Item]))
+        initialize_form_field_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options,
+          rules: @rules
+        )
+
+        validate_props!
+      end
+
+      sig { returns([ String, String ]) }
+      attr_reader :titles
+
+      sig { returns(HakumiComponents::Transfer::Operations) }
+      attr_reader :operations
+
+      sig { returns(String) }
+      def search_placeholder
+        @search_placeholder || t_default(:search_placeholder, default: "Search")
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        attrs = {
+          class: wrapper_classes,
+          data: data_attributes
+        }
+
+        merge_attributes(attrs, form_field_html_options.except(:class))
+      end
+
+      sig { returns(T::Array[HakumiComponents::Transfer::Item]) }
+      def source_items
+        @source_items ||= @data_source.reject { |item| @target_keys.include?(item.key) }
+      end
+
+      sig { returns(T::Array[HakumiComponents::Transfer::Item]) }
+      def target_items
+        @target_items ||= begin
+          item_map = @data_source.each_with_object(T.let({}, T::Hash[String, HakumiComponents::Transfer::Item])) do |item, hash|
+            hash[item.key] = item
+          end
+          @target_keys.filter_map { |key| item_map[key] }
+        end
+      end
+
+      sig { returns(T::Boolean) }
+      def show_search?
+        @show_search
+      end
+
+      sig { returns(T::Boolean) }
+      def show_select_all?
+        @show_select_all
+      end
+
+      sig { returns(T::Boolean) }
+      def disabled?
+        @disabled
+      end
+
+      sig { returns(T::Boolean) }
+      def one_way?
+        @one_way
+      end
+
+      sig { returns(T::Boolean) }
+      def pagination?
+        !@pagination.nil? && @pagination != false
+      end
+
+      sig { params(item: HakumiComponents::Transfer::Item).returns(String) }
+      def item_classes(item)
+        class_names("transfer-list-item", { disabled: item.disabled }, [ item.class_name ])
+      end
+
+      sig { params(item: HakumiComponents::Transfer::Item, panel: Symbol, index: Integer).returns(String) }
+      def item_checkbox_id(item, panel, index)
+        "#{@name}_#{panel}_#{index}_#{item.key}"
+      end
+
+      sig { params(item: HakumiComponents::Transfer::Item).returns(Types::Renderable) }
+      def item_content(item)
+        if @render_item.is_a?(Proc)
+          render_value(@render_item.call(item))
+        elsif @render_item&.respond_to?(:render_in)
+          render(@render_item)
+        else
+          item.title.to_s
+        end
+      end
+
+      sig { params(item: HakumiComponents::Transfer::Item).returns(T.nilable(Types::Renderable)) }
+      def item_description(item)
+        return nil if @render_item
+
+        render_value(item.description)
+      end
+
+      private
+
+      sig { returns(String) }
+      def wrapper_classes
+        html_class = form_field_html_options[:class]
+        class_names(
+          "transfer",
+          {
+            disabled: @disabled,
+            "show-search": @show_search,
+            "show-select-all": @show_select_all,
+            "one-way": @one_way,
+            "has-pagination": pagination?
+          },
+          html_class.is_a?(String) ? [ html_class ] : []
+        )
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def data_attributes
+        {
+          controller: "hakumi--transfer",
+          hakumi__transfer_disabled_value: @disabled,
+          hakumi__transfer_show_search_value: @show_search,
+          hakumi__transfer_show_select_all_value: @show_select_all,
+          hakumi__transfer_one_way_value: @one_way,
+          hakumi__transfer_target_keys_value: @target_keys.to_json,
+          hakumi__transfer_name_value: form_field_name.to_s,
+          hakumi__transfer_pagination_value: pagination_data_value
+        }.compact
+      end
+
+      sig { returns(PaginationDataValue) }
+      def pagination_data_value
+        return nil if @pagination.nil? || @pagination == false
+        return @pagination.to_json if @pagination.is_a?(Hash)
+
+        @pagination
+      end
+
+      sig do
+        params(
+          target_keys: T.nilable(T::Array[HakumiComponents::Types::FormFieldScalar]),
+          value: Types::FormFieldValue
+        ).returns(T::Array[String])
+      end
+      def normalize_target_keys(target_keys, value)
+        keys = target_keys.nil? ? Array(value) : Array(target_keys)
+        keys.map(&:to_s)
+      end
+
+      sig { params(titles: T.nilable(T::Array[String])).returns([ String, String ]) }
+      def normalize_titles(titles)
+        pair = titles&.first(2)
+        left = pair&.[](0) || t_default(:source_title, default: "Source")
+        right = pair&.[](1) || t_default(:target_title, default: "Target")
+        [ left, right ]
+      end
+
+      sig { returns(String) }
+      def hidden_input_name
+        "#{form_field_name}[]"
+      end
+
+      sig { params(operations: T.nilable(OperationsHash)).returns(HakumiComponents::Transfer::Operations) }
+      def normalize_operations(operations)
+        return HakumiComponents::Transfer::Operations.new(to_target: :right, to_source: :left) if operations.nil?
+
+        to_target = operations[:to_target] || operations["to_target"] || :right
+        to_source = operations[:to_source] || operations["to_source"] || :left
+
+        HakumiComponents::Transfer::Operations.new(
+          to_target: to_target.to_sym,
+          to_source: to_source.to_sym
+        )
+      end
+
+      sig { params(value: T.nilable(Types::FormFieldName)).returns(T.nilable(String)) }
+      def normalize_string(value)
+        return nil if value.nil?
+
+        normalized = value.to_s.strip
+        normalized.empty? ? nil : normalized
+      end
+
+      sig { void }
+      def validate_props!
+        nil
+      end
+
+      sig { params(value: StringOrItemsInput).returns(ItemArrayValue) }
+      def self.parse_data_source(value)
+        return [] if value.nil? || value == ""
+        return value if value.is_a?(Array)
+
+        parsed = JSON.parse(value)
+        parsed.is_a?(Array) ? parsed : []
+      rescue JSON::ParserError
+        []
+      end
+
+      sig { params(value: StringOrStringsInput).returns(StringArrayValue) }
+      def self.parse_json_array(value)
+        return [] if value.nil? || value == ""
+        return value if value.is_a?(Array)
+
+        parsed = JSON.parse(value)
+        return [] unless parsed.is_a?(Array)
+
+        parsed.map(&:to_s)
+      rescue JSON::ParserError
+        []
+      end
+
+      sig { params(value: PaginationInput).returns(PaginationValue) }
+      def self.parse_pagination(value)
+        return false if value.nil?
+        return value if value.is_a?(Hash)
+        return value if value == true || value == false
+        return false unless value.is_a?(String)
+
+        string_value = value
+        parsed = JSON.parse(string_value)
+        return parsed if parsed.is_a?(Hash) || parsed == true || parsed == false
+
+        false
+      rescue JSON::ParserError
+        cast_boolean(string_value)
+      end
+
+      sig { params(value: ControllerScalar, default: T::Boolean).returns(T::Boolean) }
+      def self.boolean_param(value, default: false)
+        return default if value.nil?
+
+        cast_boolean(value) == true
+      end
+
+      sig { params(value: ControllerParam).returns(StringOrItemsInput) }
+      def self.data_source_param(value)
+        return value if value.is_a?(String)
+
+        if value.is_a?(Array)
+          items = T.let([], T::Array[ItemInput])
+          value.each { |item| items << item if item.is_a?(HakumiComponents::Transfer::Item) || item.is_a?(Hash) || item.is_a?(String) || item.is_a?(Symbol) || item.is_a?(Numeric) || item == true || item == false || item.nil? || item.is_a?(Date) || item.is_a?(Time) || item.is_a?(DateTime) || item.is_a?(ActiveSupport::TimeWithZone) }
+          return items
+        end
+
+        nil
+      end
+
+      sig { params(value: ControllerParam).returns(StringOrStringsInput) }
+      def self.string_array_param(value)
+        return value if value.is_a?(String)
+
+        value.is_a?(Array) ? value.map(&:to_s) : nil
+      end
+
+      sig { params(value: ControllerParam).returns(ControllerScalar) }
+      def self.boolean_param_input(value)
+        return value if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value == true || value == false
+
+        nil
+      end
+
+      sig { params(value: ControllerParam).returns(PaginationInput) }
+      def self.pagination_param(value)
+        return value if value.is_a?(String) || value == true || value == false || value.is_a?(Hash)
+
+        nil
+      end
+    end
+  end
+end

data/app/components/hakumi_components/transfer/item.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Transfer
+    class Item
+      extend T::Sig
+
+      sig do
+        params(
+          key: String,
+          title: T.any(String, Symbol, Numeric),
+          description: T.nilable(String),
+          disabled: T::Boolean,
+          class_name: T.nilable(String)
+        ).void
+      end
+      def initialize(key:, title:, description:, disabled:, class_name:)
+        @key = key
+        @title = title
+        @description = description
+        @disabled = disabled
+        @class_name = class_name
+      end
+
+      sig { returns(String) }
+      attr_reader :key
+
+      sig { returns(T.any(String, Symbol, Numeric)) }
+      attr_reader :title
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :class_name
+
+      sig { params(key: Types::HtmlKey).returns(T.nilable(Types::HtmlScalar)) }
+      def [](key)
+        case key.to_sym
+        when :key then @key
+        when :title then @title
+        when :description then @description
+        when :disabled then @disabled
+        when :class_name then @class_name
+        else nil
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/transfer/operations.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Transfer
+    class Operations
+      extend T::Sig
+
+      sig { params(to_target: Symbol, to_source: Symbol).void }
+      def initialize(to_target:, to_source:)
+        @to_target = to_target
+        @to_source = to_source
+      end
+
+      sig { returns(Symbol) }
+      attr_reader :to_target
+
+      sig { returns(Symbol) }
+      attr_reader :to_source
+
+      sig { params(key: Types::HtmlKey).returns(T.nilable(Symbol)) }
+      def [](key)
+        case key.to_sym
+        when :to_target then @to_target
+        when :to_source then @to_source
+        else nil
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@
   <% if searchable? %>
     <div class="hakumi-tree-search">
       <span class="hakumi-tree-search-icon">
-        <%= render Hakumi::Icon::Component.new(name: :search) %>
+        <%= render HakumiComponents::Icon::Component.new(name: :search) %>
       </span>
       <input
         type="search"