hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,7 +1,6 @@
 <% switch_control = capture do %>
-  <% # Rails convention: hidden field with value="0" ensures unchecked state sends params %>
-  <% if @name && !standalone? %>
-    <%= tag.input(type: "hidden", name: @name, value: "0", autocomplete: "off") %>
+  <% if form_field_name && !standalone? %>
+    <%= tag.input(type: "hidden", name: form_field_name, value: "0", autocomplete: "off") %>
   <% end %>
   <%= content_tag(:label, **wrapper_attributes) do %>
     <%= tag.input(**input_attributes) %>

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

@@ -0,0 +1,150 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Switch
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include HakumiComponents::Concerns::FormField
+
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          checked: T.nilable(T::Boolean),
+          default_checked: T::Boolean,
+          disabled: T::Boolean,
+          loading: T::Boolean,
+          size: Symbol,
+          checked_text: Types::Renderable,
+          unchecked_text: Types::Renderable,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        name: nil,
+        label: nil,
+        caption: nil,
+        checked: nil,
+        default_checked: false,
+        disabled: false,
+        loading: false,
+        size: :default,
+        checked_text: nil,
+        unchecked_text: nil,
+        standalone: true,
+        required: false,
+        errors: [],
+        **html_options
+      )
+        @name = T.let(name || generate_id("switch"), Types::FormFieldName)
+        @label = label
+        @caption = caption
+        @checked = T.let(checked.nil? ? default_checked : checked, T::Boolean)
+        @disabled = disabled
+        @loading = loading
+        @size = size
+        @checked_text = checked_text
+        @unchecked_text = unchecked_text
+        @standalone = standalone
+        @required = required
+        @errors = T.let(errors, Types::FormFieldErrors)
+        wrapper_class = html_options.delete(:wrapper_class)
+        @wrapper_class = T.let(wrapper_class.is_a?(String) ? wrapper_class : nil, T.nilable(String))
+        @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
+        )
+
+        validate_props!
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        class_names(
+          "switch",
+          {
+            checked: @checked,
+            disabled: @disabled,
+            loading: @loading,
+            @size => (@size != :default)
+          },
+          [ @wrapper_class ]
+        )
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes(
+          {
+            class: wrapper_classes,
+            role: "switch",
+            tabindex: (@disabled || @loading) ? "-1" : "0",
+            "aria-checked": @checked.to_s,
+            "aria-disabled": (@disabled || @loading).to_s,
+            data: {
+              controller: "hakumi--switch",
+              hakumi__switch_checked_value: @checked,
+              hakumi__switch_disabled_value: @disabled,
+              hakumi__switch_loading_value: @loading
+            }
+          },
+          @html_options.except(:class, :wrapper_class)
+        )
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def input_attributes
+        attrs = {
+          type: "checkbox",
+          name: form_field_name,
+          id: input_id,
+          class: [ "hakumi-switch-input", @html_options[:class] ].compact.join(" "),
+          checked: @checked ? true : nil,
+          disabled: (@disabled || @loading) ? true : nil,
+          "aria-invalid": error? ? "true" : nil,
+          "aria-describedby": describedby_ids,
+          tabindex: "-1",
+          data: {
+            action: "change->hakumi--switch#toggle",
+            hakumi__switch_target: "input"
+          }
+        }.compact
+
+        if @html_options[:data]
+          attrs[:data] = attrs[:data].merge(@html_options[:data])
+        end
+
+        attrs.merge(@html_options.except(:data, :class))
+      end
+
+      sig { returns(Types::Renderable) }
+      def checked_content
+        render_value(@checked_text)
+      end
+
+      sig { returns(Types::Renderable) }
+      def unchecked_content
+        render_value(@unchecked_text)
+      end
+    end
+  end
+end

data/app/components/hakumi_components/table/column/component.rb

@@ -0,0 +1,137 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Column
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            title: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            data_index: T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey),
+            key: T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey),
+            align: T.nilable(Symbol),
+            width: HakumiComponents::Table::DefinitionTypes::WidthValue,
+            ellipsis: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            sorter: HakumiComponents::Table::DefinitionTypes::SorterValue,
+            sort_directions: T.nilable(T::Array[Symbol]),
+            sort_order: T.nilable(Symbol),
+            default_sort_order: T.nilable(Symbol),
+            filters: T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]),
+            filter_multiple: T::Boolean,
+            filtered_value: T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList),
+            default_filtered_value: T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList),
+            filter_mode: T.nilable(Symbol),
+            filter_search: HakumiComponents::Table::DefinitionTypes::SearchValue,
+            hidden: T::Boolean,
+            on_cell: T.nilable(Proc),
+            class_name: T.nilable(String),
+            responsive: T.nilable(T::Array[Symbol]),
+            fixed: T.nilable(Symbol),
+            editable: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            should_cell_update: T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey),
+            drag_handle: T::Boolean,
+            selection: T::Boolean,
+            expand: T::Boolean,
+            extra: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            block: T.nilable(Proc)
+          ).void
+        end
+        def initialize(
+          title:,
+          data_index: nil,
+          key: nil,
+          align: nil,
+          width: nil,
+          ellipsis: false,
+          sorter: nil,
+          sort_directions: nil,
+          sort_order: nil,
+          default_sort_order: nil,
+          filters: nil,
+          filter_multiple: true,
+          filtered_value: nil,
+          default_filtered_value: nil,
+          filter_mode: nil,
+          filter_search: nil,
+          hidden: false,
+          on_cell: nil,
+          class_name: nil,
+          responsive: nil,
+          fixed: nil,
+          editable: nil,
+          should_cell_update: nil,
+          drag_handle: false,
+          selection: false,
+          expand: false,
+          **extra,
+          &block
+        )
+          @title = T.let(title, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @data_index = T.let(data_index, T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey))
+          @key = T.let(key, T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey))
+          @align = T.let(align, T.nilable(Symbol))
+          @width = T.let(width, HakumiComponents::Table::DefinitionTypes::WidthValue)
+          @ellipsis = T.let(ellipsis, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @sorter = T.let(sorter, HakumiComponents::Table::DefinitionTypes::SorterValue)
+          @sort_directions = T.let(sort_directions, T.nilable(T::Array[Symbol]))
+          @sort_order = T.let(sort_order, T.nilable(Symbol))
+          @default_sort_order = T.let(default_sort_order, T.nilable(Symbol))
+          @filters = T.let(filters, T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]))
+          @filter_multiple = T.let(filter_multiple, T::Boolean)
+          @filtered_value = T.let(filtered_value, T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList))
+          @default_filtered_value = T.let(default_filtered_value, T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList))
+          @filter_mode = T.let(filter_mode, T.nilable(Symbol))
+          @filter_search = T.let(filter_search, HakumiComponents::Table::DefinitionTypes::SearchValue)
+          @hidden = T.let(hidden, T::Boolean)
+          @on_cell = T.let(on_cell, T.nilable(Proc))
+          @class_name = T.let(class_name, T.nilable(String))
+          @responsive = T.let(responsive, T.nilable(T::Array[Symbol]))
+          @fixed = T.let(fixed, T.nilable(Symbol))
+          @editable = T.let(editable, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @should_cell_update = T.let(should_cell_update, T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey))
+          @drag_handle = T.let(drag_handle, T::Boolean)
+          @selection = T.let(selection, T::Boolean)
+          @expand = T.let(expand, T::Boolean)
+          @extra = T.let(extra, T::Hash[Symbol, HakumiComponents::Table::DefinitionTypes::DefinitionValue])
+          @block = T.let(block, T.nilable(Proc))
+        end
+
+        sig { returns(HakumiComponents::Table::DefinitionTypes::DefinitionHash) }
+        def to_h
+          {
+            title: @title,
+            data_index: @data_index,
+            key: @key,
+            align: @align,
+            width: @width,
+            ellipsis: @ellipsis,
+            sorter: @sorter,
+            sort_directions: @sort_directions,
+            sort_order: @sort_order,
+            default_sort_order: @default_sort_order,
+            filters: @filters,
+            filter_multiple: @filter_multiple,
+            filtered_value: @filtered_value,
+            default_filtered_value: @default_filtered_value,
+            filter_mode: @filter_mode,
+            filter_search: @filter_search,
+            hidden: @hidden,
+            on_cell: @on_cell,
+            class_name: @class_name,
+            responsive: @responsive,
+            fixed: @fixed,
+            editable: @editable,
+            should_cell_update: @should_cell_update,
+            drag_handle: @drag_handle,
+            selection: @selection,
+            expand: @expand,
+            render: @block
+          }.merge(@extra)
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/table/column_definition.rb

@@ -0,0 +1,181 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class ColumnDefinition
+      extend T::Sig
+
+      ColumnKey = T.type_alias { HakumiComponents::Table::DefinitionTypes::ColumnKey }
+      WidthValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::WidthValue }
+      SorterValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::SorterValue }
+      FilterValues = T.type_alias { T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList) }
+      FilterSearchValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::SearchValue }
+      SortValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::SortValue }
+      EllipsisValue = T.type_alias do
+        T.nilable(T.any(
+          HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+          HakumiComponents::Table::EllipsisConfig
+        ))
+      end
+
+      sig do
+        params(
+          title: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+          key: ColumnKey,
+          data_index: T.nilable(ColumnKey),
+          align: T.nilable(Symbol),
+          width: WidthValue,
+          ellipsis: EllipsisValue,
+          sorter: SorterValue,
+          sort_directions: T.nilable(T::Array[Symbol]),
+          sort_order: T.nilable(Symbol),
+          default_sort_order: T.nilable(Symbol),
+          filters: T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]),
+          filter_multiple: T::Boolean,
+          filtered_value: FilterValues,
+          default_filtered_value: FilterValues,
+          filter_mode: T.nilable(Symbol),
+          filter_search: FilterSearchValue,
+          hidden: T::Boolean,
+          on_cell: T.nilable(Proc),
+          class_name: T.nilable(String),
+          responsive: T.nilable(T::Array[Symbol]),
+          fixed: T.nilable(Symbol),
+          editable: T.nilable(HakumiComponents::Table::Configs::ColumnEditable),
+          should_cell_update: T.nilable(String),
+          drag_handle: T::Boolean,
+          selection: T::Boolean,
+          expand: T::Boolean,
+          render: T.nilable(Proc),
+          sort_value: SortValue,
+          children: T::Array[HakumiComponents::Table::ColumnDefinition]
+        ).void
+      end
+      def initialize(
+        title:,
+        key:,
+        data_index: nil,
+        align: nil,
+        width: nil,
+        ellipsis: nil,
+        sorter: nil,
+        sort_directions: nil,
+        sort_order: nil,
+        default_sort_order: nil,
+        filters: nil,
+        filter_multiple: true,
+        filtered_value: nil,
+        default_filtered_value: nil,
+        filter_mode: nil,
+        filter_search: nil,
+        hidden: false,
+        on_cell: nil,
+        class_name: nil,
+        responsive: nil,
+        fixed: nil,
+        editable: nil,
+        should_cell_update: nil,
+        drag_handle: false,
+        selection: false,
+        expand: false,
+        render: nil,
+        sort_value: nil,
+        children: []
+      )
+        @title = T.let(title, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+        @key = T.let(key, ColumnKey)
+        @data_index = T.let(data_index, T.nilable(ColumnKey))
+        @align = T.let(align, T.nilable(Symbol))
+        @width = T.let(width, WidthValue)
+        @ellipsis = T.let(ellipsis, EllipsisValue)
+        @sorter = T.let(sorter, SorterValue)
+        @sort_directions = T.let(sort_directions, T.nilable(T::Array[Symbol]))
+        @sort_order = T.let(sort_order, T.nilable(Symbol))
+        @default_sort_order = T.let(default_sort_order, T.nilable(Symbol))
+        @filters = T.let(filters, T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]))
+        @filter_multiple = T.let(filter_multiple, T::Boolean)
+        @filtered_value = T.let(filtered_value, FilterValues)
+        @default_filtered_value = T.let(default_filtered_value, FilterValues)
+        @filter_mode = T.let(filter_mode, T.nilable(Symbol))
+        @filter_search = T.let(filter_search, FilterSearchValue)
+        @hidden = T.let(hidden, T::Boolean)
+        @on_cell = T.let(on_cell, T.nilable(Proc))
+        @class_name = T.let(class_name, T.nilable(String))
+        @responsive = T.let(responsive, T.nilable(T::Array[Symbol]))
+        @fixed = T.let(fixed, T.nilable(Symbol))
+        @editable = T.let(editable, T.nilable(HakumiComponents::Table::Configs::ColumnEditable))
+        @should_cell_update = T.let(should_cell_update, T.nilable(String))
+        @drag_handle = T.let(drag_handle, T::Boolean)
+        @selection = T.let(selection, T::Boolean)
+        @expand = T.let(expand, T::Boolean)
+        @render = T.let(render, T.nilable(Proc))
+        @sort_value = T.let(sort_value, SortValue)
+        @children = T.let(children, T::Array[HakumiComponents::Table::ColumnDefinition])
+      end
+
+      sig { returns(HakumiComponents::Table::DefinitionTypes::DefinitionValue) }
+      attr_reader :title
+
+      sig { returns(T.nilable(HakumiComponents::Table::Configs::ColumnEditable)) }
+      attr_reader :editable
+
+      sig { returns(EllipsisValue) }
+      attr_reader :ellipsis
+
+      sig { returns(ColumnKey) }
+      attr_reader :key
+
+      sig { returns(T.nilable(ColumnKey)) }
+      attr_reader :data_index
+
+      sig { returns(T.nilable(Symbol)) }
+      attr_reader :align, :sort_order, :default_sort_order, :filter_mode, :fixed
+
+      sig { returns(WidthValue) }
+      attr_reader :width
+
+      sig { returns(SorterValue) }
+      attr_reader :sorter, :filter_search
+
+      sig { returns(T.nilable(T::Array[Symbol])) }
+      attr_reader :sort_directions, :responsive
+
+      sig { returns(T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash])) }
+      attr_reader :filters
+
+      sig { returns(T::Boolean) }
+      attr_reader :filter_multiple, :hidden, :drag_handle, :selection, :expand
+
+      sig { returns(FilterValues) }
+      attr_reader :filtered_value, :default_filtered_value
+
+      sig { returns(T.nilable(Proc)) }
+      attr_reader :on_cell, :render
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :class_name, :should_cell_update
+
+      sig { returns(SortValue) }
+      attr_reader :sort_value
+
+      sig { returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+      attr_reader :children
+
+      sig { returns(T::Boolean) }
+      def selection?
+        @selection
+      end
+
+      sig { returns(T::Boolean) }
+      def expand?
+        @expand
+      end
+
+      sig { returns(T::Boolean) }
+      def drag_handle?
+        @drag_handle
+      end
+    end
+  end
+end

data/app/components/{hakumi → hakumi_components}/table/column_group/component.rb

@@ -1,17 +1,21 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Table
     module ColumnGroup
-      class Component < Hakumi::BaseComponent
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
         renders_many :columns, types: {
           column: {
             renders: lambda do |title:, data_index: nil, key: nil, align: nil, width: nil, ellipsis: false,
                                 sorter: nil, sort_directions: nil, sort_order: nil, default_sort_order: nil,
                                 filters: nil, filter_multiple: true, filtered_value: nil, default_filtered_value: nil,
                                 filter_mode: nil, filter_search: nil, hidden: false, on_cell: nil, class_name: nil,
-                                **options, &block|
-              Hakumi::Table::Column::Component.new(
+                                responsive: nil, fixed: nil, editable: nil, should_cell_update: nil,
+                                drag_handle: false, selection: false, expand: false, &block|
+              HakumiComponents::Table::Column::Component.new(
                 title: title,
                 data_index: data_index,
                 key: key,
@@ -31,37 +35,44 @@ module Hakumi
                 hidden: hidden,
                 on_cell: on_cell,
                 class_name: class_name,
-                **options,
+                responsive: responsive,
+                fixed: fixed,
+                editable: editable,
+                should_cell_update: should_cell_update,
+                drag_handle: drag_handle,
+                selection: selection,
+                expand: expand,
                 &block
               )
             end,
             as: :column
           },
           group: {
-            renders: lambda do |title:, key: nil, align: nil, width: nil, hidden: false, **options, &block|
-              Hakumi::Table::ColumnGroup::Component.new(
-                title: title,
-                key: key,
-                align: align,
-                width: width,
-                hidden: hidden,
-                **options,
-                &block
-              )
-            end,
+            renders: HakumiComponents::Table::ColumnGroup::Component,
             as: :group
           }
         }
 
-        def initialize(title:, key: nil, align: nil, width: nil, hidden: false, **options)
-          @title = title
-          @key = key
-          @align = align
-          @width = width
-          @hidden = hidden
-          @options = options
+        sig do
+          params(
+            title: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            key: T.nilable(Types::StringOrSymbol),
+            align: T.nilable(Symbol),
+            width: T.nilable(T.any(String, Numeric)),
+            hidden: T::Boolean,
+            extra: HakumiComponents::Table::DefinitionTypes::DefinitionValue
+          ).void
+        end
+        def initialize(title:, key: nil, align: nil, width: nil, hidden: false, **extra)
+          @title = T.let(title, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @key = T.let(key, T.nilable(Types::StringOrSymbol))
+          @align = T.let(align, T.nilable(Symbol))
+          @width = T.let(width, T.nilable(T.any(String, Numeric)))
+          @hidden = T.let(hidden, T::Boolean)
+          @extra = T.let(extra, T::Hash[Symbol, HakumiComponents::Table::DefinitionTypes::DefinitionValue])
         end
 
+        sig { returns(HakumiComponents::Table::DefinitionTypes::DefinitionHash) }
         def to_h
           {
             title: @title,
@@ -70,7 +81,7 @@ module Hakumi
             width: @width,
             hidden: @hidden,
             children: columns.map(&:to_h)
-          }.merge(@options)
+          }.merge(@extra)
         end
       end
     end