hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,129 +1,230 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Transfer
     class Component < HakumiComponents::BaseComponent
-      DEFAULT_TITLES = [ "Source", "Target" ].freeze
+      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(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]),
+          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: [],
+        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,
-        name: nil,
+        standalone: true,
+        rules: nil,
+        errors: [],
         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)
+        @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
-        @html_options = html_options
+        @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
 
-      attr_reader :titles, :operations
+      sig { returns([ String, String ]) }
+      attr_reader :titles
 
+      sig { returns(HakumiComponents::Transfer::Operations) }
+      attr_reader :operations
+
+      sig { returns(String) }
       def search_placeholder
-        @search_placeholder || "Search"
+        @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, @html_options.except(:class))
+        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]) }
+        @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.index_by { |item| item[:key] }
+          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.present? && @pagination != false
+        !@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] ])
+        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]}"
+        "#{@name}_#{panel}_#{index}_#{item.key}"
       end
 
+      sig { params(item: HakumiComponents::Transfer::Item).returns(Types::Renderable) }
       def item_content(item)
-        if @render_item.respond_to?(:call)
+        if @render_item.is_a?(Proc)
           render_value(@render_item.call(item))
         elsif @render_item&.respond_to?(:render_in)
           render(@render_item)
         else
-          render_value(item[:title])
+          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.present?
+        return nil if @render_item
 
-        render_value(item[:description])
+        render_value(item.description)
       end
 
       private
 
+      sig { returns(String) }
       def wrapper_classes
+        html_class = form_field_html_options[:class]
         class_names(
           "transfer",
           {
@@ -133,10 +234,11 @@ module HakumiComponents
             "one-way": @one_way,
             "has-pagination": pagination?
           },
-          [ @html_options[:class] ]
+          html_class.is_a?(String) ? [ html_class ] : []
         )
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
         {
           controller: "hakumi--transfer",
@@ -145,100 +247,148 @@ module HakumiComponents
           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_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.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
+        @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)
-        titles = Array(titles).presence
-        left = titles&.[](0) || DEFAULT_TITLES[0]
-        right = titles&.[](1) || DEFAULT_TITLES[1]
+        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 { to_target: :right, to_source: :left } if operations.nil?
+        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
-        }
+        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?
 
-        value = value.to_s.strip
-        value.presence
+        normalized = value.to_s.strip
+        normalized.empty? ? nil : normalized
       end
 
+      sig { void }
       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)
+        nil
       end
 
+      sig { params(value: StringOrItemsInput).returns(ItemArrayValue) }
       def self.parse_data_source(value)
-        return [] if value.blank?
+        return [] if value.nil? || value == ""
         return value if value.is_a?(Array)
 
-        JSON.parse(value)
+        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.blank?
+        return [] if value.nil? || value == ""
         return value if value.is_a?(Array)
 
-        JSON.parse(value)
+        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) || value == true || value == false
+        return value if value.is_a?(Hash)
+        return value if value == true || value == false
+        return false unless value.is_a?(String)
 
-        JSON.parse(value)
+        string_value = value
+        parsed = JSON.parse(string_value)
+        return parsed if parsed.is_a?(Hash) || parsed == true || parsed == false
+
+        false
       rescue JSON::ParserError
-        ActiveModel::Type::Boolean.new.cast(value)
+        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?
 
-        ActiveModel::Type::Boolean.new.cast(value)
+        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

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