hakumi_components 0.1.3.pre

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Hakumi
+  module Transfer
+    class Component < Hakumi::BaseComponent
+      DEFAULT_TITLES = [ "Source", "Target" ].freeze
+
+      def self.extract_controller_locals(params)
+        {
+          data_source: parse_data_source(params[:data_source]),
+          target_keys: parse_json_array(params[:target_keys]),
+          titles: parse_json_array(params[:titles]),
+          disabled: boolean_param(params[:disabled]),
+          show_search: boolean_param(params[:show_search]),
+          show_select_all: boolean_param(params[:show_select_all], default: true),
+          one_way: boolean_param(params[:one_way]),
+          pagination: parse_pagination(params[:pagination]),
+          name: params[:name]
+        }.compact
+      end
+
+      def initialize(
+        data_source:,
+        target_keys: [],
+        titles: nil,
+        disabled: false,
+        show_search: false,
+        show_select_all: true,
+        one_way: false,
+        pagination: false,
+        name: nil,
+        render_item: nil,
+        operations: nil,
+        search_placeholder: nil,
+        **html_options
+      )
+        @data_source = normalize_data_source(data_source)
+        @target_keys = Array(target_keys).map(&:to_s)
+        @titles = normalize_titles(titles)
+        @disabled = cast_boolean(disabled)
+        @show_search = cast_boolean(show_search)
+        @show_select_all = cast_boolean(show_select_all)
+        @one_way = cast_boolean(one_way)
+        @pagination = pagination
+        @name = normalize_string(name) || generate_id("transfer")
+        @render_item = render_item
+        @operations = normalize_operations(operations)
+        @search_placeholder = search_placeholder
+        @html_options = html_options
+
+        validate_props!
+      end
+
+      attr_reader :titles, :operations
+
+      def search_placeholder
+        @search_placeholder || "Search"
+      end
+
+      def wrapper_attributes
+        attrs = {
+          class: wrapper_classes,
+          data: data_attributes
+        }
+
+        merge_attributes(attrs, @html_options.except(:class))
+      end
+
+      def source_items
+        @source_items ||= @data_source.reject { |item| @target_keys.include?(item[:key]) }
+      end
+
+      def target_items
+        @target_items ||= begin
+          item_map = @data_source.index_by { |item| item[:key] }
+          @target_keys.filter_map { |key| item_map[key] }
+        end
+      end
+
+      def show_search?
+        @show_search
+      end
+
+      def show_select_all?
+        @show_select_all
+      end
+
+      def disabled?
+        @disabled
+      end
+
+      def one_way?
+        @one_way
+      end
+
+      def pagination?
+        @pagination.present? && @pagination != false
+      end
+
+      def item_classes(item)
+        class_names("transfer-list-item", { disabled: item[:disabled] }, [ item[:class_name] ])
+      end
+
+      def item_checkbox_id(item, panel, index)
+        "#{@name}_#{panel}_#{index}_#{item[:key]}"
+      end
+
+      def item_content(item)
+        if @render_item.respond_to?(:call)
+          render_value(@render_item.call(item))
+        elsif @render_item&.respond_to?(:render_in)
+          render(@render_item)
+        else
+          render_value(item[:title])
+        end
+      end
+
+      def item_description(item)
+        return nil if @render_item.present?
+
+        render_value(item[:description])
+      end
+
+      private
+
+      def wrapper_classes
+        class_names(
+          "transfer",
+          {
+            disabled: @disabled,
+            "show-search": @show_search,
+            "show-select-all": @show_select_all,
+            "one-way": @one_way,
+            "has-pagination": pagination?
+          },
+          [ @html_options[:class] ]
+        )
+      end
+
+      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: @name,
+          hakumi__transfer_pagination_value: pagination_data_value
+        }.compact
+      end
+
+      def pagination_data_value
+        return nil if @pagination.nil? || @pagination == false
+
+        @pagination.is_a?(Hash) ? @pagination.to_json : @pagination
+      end
+
+      def normalize_data_source(data_source)
+        Array(data_source).map.with_index do |item, index|
+          if item.is_a?(Hash)
+            key = item[:key] || item["key"] || index
+            title = item[:title] || item["title"] || key
+            {
+              key: key.to_s,
+              title: title,
+              description: item[:description] || item["description"],
+              disabled: @disabled || cast_boolean(item[:disabled] || item["disabled"]),
+              class_name: item[:class_name] || item["class_name"]
+            }
+          else
+            {
+              key: item.to_s,
+              title: item,
+              description: nil,
+              disabled: @disabled,
+              class_name: nil
+            }
+          end
+        end
+      end
+
+      def normalize_titles(titles)
+        titles = Array(titles).presence
+        left = titles&.[](0) || DEFAULT_TITLES[0]
+        right = titles&.[](1) || DEFAULT_TITLES[1]
+        [ left, right ]
+      end
+
+      def normalize_operations(operations)
+        return { 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
+        }
+      end
+
+      def cast_boolean(value)
+        ActiveModel::Type::Boolean.new.cast(value)
+      end
+
+      def normalize_string(value)
+        return nil if value.nil?
+
+        value = value.to_s.strip
+        value.presence
+      end
+
+      def validate_props!
+        raise ArgumentError, "data_source is required" if @data_source.nil?
+        raise ArgumentError, "data_source must be an Array" unless @data_source.is_a?(Array)
+      end
+
+      def self.parse_data_source(value)
+        return [] if value.blank?
+        return value if value.is_a?(Array)
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        []
+      end
+
+      def self.parse_json_array(value)
+        return [] if value.blank?
+        return value if value.is_a?(Array)
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        []
+      end
+
+      def self.parse_pagination(value)
+        return false if value.nil?
+        return value if value.is_a?(Hash) || value == true || value == false
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        ActiveModel::Type::Boolean.new.cast(value)
+      end
+
+      def self.boolean_param(value, default: false)
+        return default if value.nil?
+
+        ActiveModel::Type::Boolean.new.cast(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+<div <%= tag.attributes(wrapper_attributes) %>>
+  <% if searchable? %>
+    <div class="hakumi-tree-search">
+      <span class="hakumi-tree-search-icon">
+        <%= render Hakumi::Icon::Component.new(name: :search) %>
+      </span>
+      <input
+        type="search"
+        class="hakumi-tree-search-input"
+        placeholder="<%= search_placeholder %>"
+        data-hakumi--tree-target="searchInput"
+        data-action="input->hakumi--tree#search">
+    </div>
+  <% end %>
+
+  <template data-hakumi--tree-target="nodeTemplate">
+    <%= render_node_template %>
+  </template>
+
+  <div <%= tag.attributes(list_attributes) %>>
+    <%= render_nodes(normalized_nodes) %>
+  </div>
+</div>