hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,15 +1,62 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Upload
-    # Hakumi Upload component
-    # Provides file selection, drag-and-drop, and upload list management.
     class Component < HakumiComponents::BaseComponent
-      LIST_TYPES = %i[text picture picture_card avatar].freeze
+      extend T::Sig
+      include HakumiComponents::Concerns::FormField
 
+      PayloadValue = T.type_alias { T.nilable(Types::ValidationComparable) }
+      PayloadHash = T.type_alias { T::Hash[Types::HtmlKey, PayloadValue] }
+      FileListHash = T.type_alias { T::Hash[Types::HtmlKey, PayloadValue] }
+      FileListInput = T.type_alias { T.any(HakumiComponents::Upload::FileEntry, FileListHash, String, Symbol) }
+      AvatarSize = T.type_alias { T.any(Symbol, Integer) }
+      AvatarIcon = T.type_alias { Types::HtmlKey }
+      FileListScalar = T.type_alias { Types::StringOrSymbol }
+
+      LIST_TYPES = T.let(%i[text picture picture_card avatar].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          action: String,
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          accept: T.nilable(String),
+          multiple: T::Boolean,
+          max_count: T.nilable(Integer),
+          max_size: T.nilable(Integer),
+          disabled: T::Boolean,
+          list_type: Symbol,
+          show_upload_list: T::Boolean,
+          drag: T::Boolean,
+          headers: T.nilable(PayloadHash),
+          data: T.nilable(PayloadHash),
+          default_file_list: T::Array[FileListInput],
+          with_credentials: T::Boolean,
+          auto_upload: T::Boolean,
+          inline_trigger: T::Boolean,
+          required: T::Boolean,
+          standalone: T::Boolean,
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          avatar_shape: Symbol,
+          avatar_size: AvatarSize,
+          avatar_icon: AvatarIcon,
+          preview_label: T.nilable(String),
+          remove_label: T.nilable(String),
+          close_label: T.nilable(String),
+          previous_label: T.nilable(String),
+          next_label: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         action:,
         name:,
+        label: nil,
+        caption: nil,
         accept: nil,
         multiple: false,
         max_count: nil,
@@ -24,36 +71,68 @@ module HakumiComponents
         with_credentials: false,
         auto_upload: true,
         inline_trigger: false,
+        required: false,
+        standalone: true,
+        rules: nil,
+        errors: [],
         avatar_shape: :circle,
         avatar_size: 80,
         avatar_icon: :user,
+        preview_label: nil,
+        remove_label: nil,
+        close_label: nil,
+        previous_label: nil,
+        next_label: nil,
         **html_options
       )
         @action = action
         @name = name
+        @label = label
+        @caption = caption
         @accept = accept
         @multiple = multiple
         @max_count = max_count
         @max_size = max_size
-        @disabled = disabled
+        @disabled = T.let(cast_boolean(disabled) == true, T::Boolean)
         @list_type = list_type
-        @show_upload_list = show_upload_list
-        @drag = drag
-        @headers = headers
-        @data = data
-        @default_file_list = default_file_list
-        @with_credentials = with_credentials
-        @auto_upload = auto_upload
-        @inline_trigger = inline_trigger
+        @show_upload_list = T.let(cast_boolean(show_upload_list) != false, T::Boolean)
+        @drag = T.let(cast_boolean(drag) == true, T::Boolean)
+        @headers = T.let(normalize_payload(headers), T.nilable(T::Hash[Symbol, PayloadValue]))
+        @data = T.let(normalize_payload(data), T.nilable(T::Hash[Symbol, PayloadValue]))
+        @default_file_list = T.let(normalize_file_list(default_file_list), T::Array[HakumiComponents::Upload::FileEntry])
+        @with_credentials = T.let(cast_boolean(with_credentials) == true, T::Boolean)
+        @auto_upload = T.let(cast_boolean(auto_upload) != false, T::Boolean)
+        @inline_trigger = T.let(cast_boolean(inline_trigger) == 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)
         @avatar_shape = avatar_shape
         @avatar_size = avatar_size
         @avatar_icon = avatar_icon
-        @html_options = html_options
+        @preview_label = preview_label
+        @remove_label = remove_label
+        @close_label = close_label
+        @previous_label = previous_label
+        @next_label = next_label
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        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) }
       def wrapper_classes
+        html_class = form_field_html_options[:class]
         class_names(
           "upload",
           {
@@ -61,61 +140,60 @@ module HakumiComponents
             drag: @drag,
             list: list_type_class
           },
-          [ @html_options[:class] ]
+          html_class.is_a?(String) ? [ html_class ] : []
         )
       end
 
+      sig { returns(String) }
       def upload_list_classes
         list_classes = [ "hakumi-upload-list", "hakumi-upload-list-#{list_type_class}" ]
         list_classes << "hakumi-upload-list-empty" if normalized_file_list.empty?
         list_classes.compact.join(" ")
       end
 
+      sig { params(file: HakumiComponents::Upload::FileEntry).returns(String) }
       def file_item_classes(file)
-        classes = [ "hakumi-upload-list-item", "hakumi-upload-list-item-#{file[:status] || 'done'}" ]
-        classes << "hakumi-upload-list-item-disabled" if @disabled
+        classes = [ "hakumi-upload-list-item", "hakumi-upload-list-item-#{file.status}" ]
+        classes << "hakumi-upload-list-item-disabled" if disabled?
         classes.join(" ")
       end
 
+      sig { returns(T::Boolean) }
       def list_type_picture?
         %i[picture picture_card].include?(@list_type)
       end
 
+      sig { returns(String) }
       def list_type_class
         @list_type.to_s.tr("_", "-")
       end
 
+      sig { params(file: HakumiComponents::Upload::FileEntry).returns(Integer) }
       def progress_percent(file)
-        (file[:percent] || 0).to_i
+        file.percent
       end
 
+      sig { params(file: HakumiComponents::Upload::FileEntry).returns(T.nilable(String)) }
       def progress_style(file)
         percent = progress_percent(file)
         percent.positive? ? "--hakumi-upload-progress: #{percent}%" : nil
       end
 
+      sig { returns(T::Array[HakumiComponents::Upload::FileEntry]) }
       def normalized_file_list
-        Array(@default_file_list).map.with_index do |file, index|
-          hash = file.respond_to?(:to_h) ? file.to_h : { name: file.to_s }
-          hash = hash.symbolize_keys
-          hash[:uid] ||= "upload_#{index + 1}"
-          hash[:status] ||= "done"
-          hash
-        end
+        @default_file_list
       end
 
+      sig { returns(Types::Renderable) }
       def action_label
         content.presence || "Upload"
       end
 
-      def stimulus_controller
-        "hakumi--upload"
-      end
-
+      sig { returns(Types::StimulusValues) }
       def stimulus_values
         {
           action: @action,
-          name: @name,
+          name: form_field_name.to_s,
           accept: @accept,
           multiple: @multiple,
           maxCount: @max_count,
@@ -126,55 +204,107 @@ module HakumiComponents
           drag: @drag,
           headers: @headers,
           data: @data,
-          defaultFileList: normalized_file_list,
+          defaultFileList: normalized_file_list.map(&:to_h),
           withCredentials: @with_credentials,
           autoUpload: @auto_upload,
           inlineTrigger: @inline_trigger,
           avatarShape: @avatar_shape,
           avatarSize: @avatar_size,
-          avatarIcon: @avatar_icon
+          avatarIcon: @avatar_icon,
+          previewLabel: preview_label_text,
+          removeLabel: remove_label_text,
+          closeLabel: close_label_text,
+          previousLabel: previous_label_text,
+          nextLabel: next_label_text
         }
       end
 
+      sig { returns(String) }
+      def preview_label_text
+        @preview_label || t_default(:preview, default: "Preview")
+      end
+
+      sig { returns(String) }
+      def remove_label_text
+        @remove_label || t_default(:remove, default: "Remove")
+      end
+
+      sig { returns(String) }
+      def close_label_text
+        @close_label || t_default(:close, default: "Close")
+      end
+
+      sig { returns(String) }
+      def previous_label_text
+        @previous_label || t_default(:previous, default: "Previous")
+      end
+
+      sig { returns(String) }
+      def next_label_text
+        @next_label || t_default(:next, default: "Next")
+      end
+
+      sig { returns(T::Boolean) }
       def list_type_avatar?
         @list_type == :avatar
       end
 
+      sig { returns(String) }
       def avatar_overlay_class
         @avatar_shape == :circle ? "hakumi-upload-avatar-overlay--circle" : "hakumi-upload-avatar-overlay--square"
       end
 
-      def inline_trigger?
-        @inline_trigger
+      sig { returns(AvatarIcon) }
+      attr_reader :avatar_icon
+
+      sig { returns(AvatarSize) }
+      attr_reader :avatar_size
+
+      sig { returns(Symbol) }
+      attr_reader :avatar_shape
+
+      sig { returns(T::Boolean) }
+      def disabled?
+        @disabled
       end
 
-      def stimulus_data_attributes
-        stimulus_values.each_with_object({}) do |(key, value), attrs|
-          next if value.nil?
+      sig { returns(T::Boolean) }
+      def drag?
+        @drag
+      end
 
-          attrs["#{stimulus_controller}-#{key.to_s.underscore.dasherize}-value"] =
-            value.is_a?(Array) || value.is_a?(Hash) ? value.to_json : value
-        end
+      sig { returns(T::Boolean) }
+      def show_upload_list?
+        @show_upload_list
       end
 
-      def wrapper_attributes
-        base_attrs = {
-          class: wrapper_classes,
-          data: {
-            controller: stimulus_controller
-          }.merge(stimulus_data_attributes)
-        }
+      sig { returns(T::Boolean) }
+      def picture_card?
+        @list_type == :picture_card
+      end
 
-        merge_attributes(base_attrs, @html_options.except(:class))
+      sig { returns(T::Boolean) }
+      def inline_trigger?
+        @inline_trigger
       end
 
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        data = stimulus_attrs("hakumi--upload", stimulus_values)
+        merge_attributes({ class: wrapper_classes, data: data }, form_field_html_options.except(:class))
+      end
+
+      sig { returns(Types::HtmlAttributes) }
       def input_attributes
         {
           type: "file",
-          name: @name,
+          id: input_id,
+          name: form_field_name,
           accept: @accept,
           multiple: @multiple ? true : nil,
           disabled: @disabled ? true : nil,
+          "aria-invalid": error? ? "true" : nil,
+          "aria-describedby": describedby_ids,
           data: {
             action: "change->hakumi--upload#handleInput",
             hakumi__upload_target: "input"
@@ -184,10 +314,54 @@ module HakumiComponents
 
       private
 
+      sig { void }
       def validate_props!
         validate_required!(:action, :name)
         validate_inclusion!(:list_type, LIST_TYPES)
       end
+
+      sig { params(payload: T.nilable(PayloadHash)).returns(T.nilable(T::Hash[Symbol, PayloadValue])) }
+      def normalize_payload(payload)
+        return nil if payload.nil?
+
+        payload.each_with_object(T.let({}, T::Hash[Symbol, PayloadValue])) do |(key, value), normalized|
+          normalized[key.to_sym] = value
+        end
+      end
+
+      sig { params(files: T::Array[FileListInput]).returns(T::Array[HakumiComponents::Upload::FileEntry]) }
+      def normalize_file_list(files)
+        files.map.with_index do |file, index|
+          normalize_file_entry(file, index)
+        end
+      end
+
+      sig { params(file: FileListInput, index: Integer).returns(HakumiComponents::Upload::FileEntry) }
+      def normalize_file_entry(file, index)
+        return file if file.is_a?(HakumiComponents::Upload::FileEntry)
+
+        hash = file.is_a?(Hash) ? file : { name: file.to_s }
+        uid = hash[:uid] || hash["uid"] || "upload_#{index + 1}"
+        name = hash[:name] || hash["name"] || file.to_s
+        status = hash[:status] || hash["status"] || "done"
+        percent = hash[:percent] || hash["percent"] || 0
+        url = hash[:url] || hash["url"]
+
+        HakumiComponents::Upload::FileEntry.new(
+          uid: uid.to_s,
+          name: name.to_s,
+          status: status.to_s,
+          percent: normalize_percent(percent),
+          url: url&.to_s
+        )
+      end
+
+      sig { params(value: Types::ValidationComparable).returns(Integer) }
+      def normalize_percent(value)
+        return value.to_i if value.is_a?(Numeric) || value.is_a?(String)
+
+        0
+      end
     end
   end
 end

data/app/components/hakumi_components/upload/file_entry.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Upload
+    class FileEntry
+      extend T::Sig
+
+      sig do
+        params(
+          uid: String,
+          name: String,
+          status: String,
+          percent: Integer,
+          url: T.nilable(String)
+        ).void
+      end
+      def initialize(uid:, name:, status:, percent:, url:)
+        @uid = uid
+        @name = name
+        @status = status
+        @percent = percent
+        @url = url
+      end
+
+      sig { returns(String) }
+      attr_reader :uid
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(String) }
+      attr_reader :status
+
+      sig { returns(Integer) }
+      attr_reader :percent
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+
+      sig { returns(T::Hash[Symbol, T.any(String, Integer, T.nilable(String))]) }
+      def to_h
+        {
+          uid: @uid,
+          name: @name,
+          status: @status,
+          percent: @percent,
+          url: @url
+        }
+      end
+    end
+  end
+end

data/app/controllers/hakumi_components/components_controller.rb

@@ -1,8 +1,9 @@
+# typed: false
 # frozen_string_literal: true
 
 module HakumiComponents
   class ComponentsController < ApplicationController
-    COMPONENTS = %i[modal confirm alert drawer message admin_panel notification popconfirm popover result skeleton spin affix qr_code segmented statistic table tag timeline tree].freeze
+    COMPONENTS = %i[modal confirm alert drawer message notification popconfirm popover result skeleton spin affix qr_code segmented statistic table tag timeline tree].freeze
 
     COMPONENTS.each do |component_name|
       define_method(component_name) do

data/app/form_builders/hakumi_components/form_builder/contracts.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+class HakumiComponents::FormBuilder < ActionView::Helpers::FormBuilder
+  module Contracts
+    extend T::Sig
+
+    BuilderRenderable = T.type_alias { T.any(ActiveSupport::SafeBuffer, ViewComponent::Base) }
+    BuilderScalar = T.type_alias { T.nilable(T.any(HakumiComponents::Types::ValidationPrimitive, Date, Time, DateTime, ActiveSupport::TimeWithZone)) }
+    OptionScalar = T.type_alias do
+      T.nilable(T.any(
+        BuilderScalar,
+        BuilderRenderable,
+        Regexp,
+        Proc
+      ))
+    end
+    OptionHash = T.type_alias { T::Hash[Symbol, OptionScalar] }
+    BuilderHtmlOptions = T.type_alias { T::Hash[Symbol, HakumiComponents::Types::HtmlPrimitive] }
+    BuilderInitScalar = T.type_alias { T.nilable(T.any(HakumiComponents::Types::ValidationPrimitive, Proc, ActionView::Helpers::FormBuilder)) }
+    BuilderInitValue = T.type_alias do
+      T.nilable(T.any(BuilderInitScalar, BuilderHtmlOptions))
+    end
+    BuilderInitOptions = T.type_alias { T::Hash[Symbol, BuilderInitValue] }
+    MixedCollection = T.type_alias do
+      T::Array[T.any(
+        HakumiComponents::SelectionControl::Entry,
+        HakumiComponents::SelectionControl::TreeNode,
+        HakumiComponents::Mentions::Option,
+        HakumiComponents::Transfer::Item
+      )]
+    end
+    OptionValue = T.type_alias do
+      T.any(
+        OptionScalar,
+        T::Array[OptionScalar],
+        OptionHash,
+        T::Array[OptionHash],
+        MixedCollection,
+        T::Array[HakumiComponents::SelectionControl::Option],
+        T::Array[HakumiComponents::SelectionControl::Entry],
+        T::Array[HakumiComponents::SelectionControl::TreeNode],
+        T::Array[HakumiComponents::Mentions::Option],
+        T::Array[HakumiComponents::Transfer::Item],
+        T::Array[HakumiComponents::Radio::Group::Option],
+        T::Array[HakumiComponents::SelectionControl::Coercion::FlatOptionInput],
+        T::Array[HakumiComponents::SelectionControl::Coercion::EntryInput],
+        T::Array[HakumiComponents::Transfer::Coercion::ItemInput],
+        T::Array[HakumiComponents::Mentions::Coercion::OptionInput],
+        T::Array[HakumiComponents::Types::ValidationRule]
+      )
+    end
+    OptionsHash = T.type_alias { T::Hash[Symbol, OptionValue] }
+  end
+end

data/app/form_builders/hakumi_components/form_builder/field_context.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+class HakumiComponents::FormBuilder::FieldContext
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_reader :name
+
+  sig { returns(String) }
+  attr_reader :id
+
+  sig { returns(HakumiComponents::Types::FormFieldValue) }
+  attr_reader :value
+
+  sig { returns(T::Array[String]) }
+  attr_reader :errors
+
+  sig do
+    params(
+      name: String,
+      id: String,
+      value: HakumiComponents::Types::FormFieldValue,
+      errors: T::Array[String]
+    ).void
+  end
+  def initialize(name:, id:, value:, errors:)
+    @name = T.let(name, String)
+    @id = T.let(id, String)
+    @value = T.let(value, HakumiComponents::Types::FormFieldValue)
+    @errors = T.let(errors, T::Array[String])
+  end
+
+  sig { returns(HakumiComponents::Types::FormFieldConfig) }
+  def to_options
+    {
+      name: @name,
+      id: @id,
+      value: @value,
+      errors: @errors
+    }
+  end
+end