hakumi_components 0.1.18.pre → 0.1.19.pre

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_components/table/column_group/component.rb

@@ -1,16 +1,20 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Table
     module ColumnGroup
       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|
+                                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,
@@ -31,37 +35,44 @@ module HakumiComponents
                 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|
-              HakumiComponents::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 HakumiComponents
             width: @width,
             hidden: @hidden,
             children: columns.map(&:to_h)
-          }.merge(@options)
+          }.merge(@extra)
         end
       end
     end

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

@@ -7,9 +7,9 @@
 
   <% if selection_actions? %>
     <div class="hakumi-table-selection-actions">
-      <button type="button" data-action="click->hakumi--table#selectAll">Select all</button>
-      <button type="button" data-action="click->hakumi--table#invertSelection">Invert</button>
-      <button type="button" data-action="click->hakumi--table#clearSelection">Clear</button>
+      <button type="button" data-action="click->hakumi--table#selectAll"><%= select_all_text %></button>
+      <button type="button" data-action="click->hakumi--table#invertSelection"><%= invert_text %></button>
+      <button type="button" data-action="click->hakumi--table#clearSelection"><%= clear_text %></button>
     </div>
   <% end %>
 
@@ -19,19 +19,10 @@
         <% header_rows.each do |row| %>
           <tr class="hakumi-table-header-row">
             <% row.each do |cell| %>
-              <% column = cell[:column] %>
-              <th <%= tag.attributes(header_cell_attributes(column, col_span: cell[:col_span], row_span: cell[:row_span])) %>
-                  data-column-key="<%= column[:key] %>"
-                  data-field="<%= column[:data_index] %>"
-                  <% if column[:sort_value] %>data-sort-field="<%= column[:sort_value] %>"<% end %>
-                  <% if column_sortable?(column) %>data-action="click->hakumi--table#toggleSort"<% end %>
-                  <% if column_filterable?(column) %>data-hakumi--table-target="filterToggle"<% end %>
-                  data-sortable="<%= column_sortable?(column) %>"
-                  data-filterable="<%= column_filterable?(column) %>"
-                  data-default-sort="<%= default_sort_order(column) %>"
-                  data-default-filter="<%= default_filtered_values(column).to_json %>">
+              <% column = cell.column %>
+              <th <%= tag.attributes(header_cell_attributes(column, col_span: cell.col_span, row_span: cell.row_span)) %>>
                 <div class="hakumi-table-header-cell-content">
-                  <% if column[:selection] && selection_all_enabled? %>
+                  <% if column.selection? && selection_all_enabled? %>
                     <% header_state = selection_header_state %>
                     <input type="checkbox"
                            class="hakumi-table-selection-input"
@@ -39,13 +30,13 @@
                            data-action="change->hakumi--table#toggleAll"
                            <%= "checked" if header_state[:checked] %>
                            <%= "data-indeterminate=true" if header_state[:indeterminate] %>>
-                  <% elsif column[:expand] %>
+                  <% elsif column.expand? %>
                     <span class="hakumi-table-header-title"></span>
-                  <% elsif column[:drag_handle] %>
+                  <% elsif column.drag_handle? %>
                     <span class="hakumi-table-header-title"></span>
                   <% else %>
                     <span class="hakumi-table-header-title">
-                      <%= column[:title].respond_to?(:call) ? column[:title].call : column[:title] %>
+                      <%= column.title.respond_to?(:call) ? column.title.call : column.title %>
                     </span>
                   <% end %>
                   <% if column_sortable?(column) %>
@@ -59,10 +50,10 @@
                       <summary class="hakumi-table-filter-trigger" data-action="click->hakumi--table#toggleFilter">
                         <span class="hakumi-table-filter-icon" aria-hidden="true"></span>
                       </summary>
-                      <div class="hakumi-table-filter-dropdown" data-hakumi--table-target="filterDropdown" data-column-key="<%= column[:key] %>" data-filter-multiple="<%= column_filter_multiple?(column) %>">
-                        <% if @filter_search || column[:filter_search] %>
+                      <div class="hakumi-table-filter-dropdown" data-hakumi--table-target="filterDropdown" data-column-key="<%= column.key %>" data-filter-multiple="<%= column_filter_multiple?(column) %>">
+                        <% if @filter_search || column.filter_search %>
                           <div class="hakumi-table-filter-search">
-                            <input type="text" placeholder="Search" data-action="input->hakumi--table#filterSearch" data-hakumi--table-target="filterSearch">
+                            <input type="text" placeholder="<%= search_placeholder_text %>" data-action="input->hakumi--table#filterSearch" data-hakumi--table-target="filterSearch">
                           </div>
                         <% end %>
                         <div class="hakumi-table-filter-options">
@@ -72,7 +63,7 @@
                             <label class="hakumi-table-filter-option">
                               <input
                                 type="<%= column_filter_multiple?(column) ? 'checkbox' : 'radio' %>"
-                                name="filter-<%= column[:key] %>"
+                                name="filter-<%= column.key %>"
                                 value="<%= value %>"
                                 data-action="change->hakumi--table#applyFilters"
                                 data-hakumi--table-target="filterOption"
@@ -82,7 +73,7 @@
                           <% end %>
                         </div>
                         <div class="hakumi-table-filter-actions">
-                          <button type="button" class="hakumi-table-filter-clear" data-action="click->hakumi--table#clearFilters">Reset</button>
+                          <button type="button" class="hakumi-table-filter-clear" data-action="click->hakumi--table#clearFilters"><%= reset_text %></button>
                           <button type="button" class="hakumi-table-filter-confirm" data-action="click->hakumi--table#confirmFilters">OK</button>
                         </div>
                       </div>
@@ -96,19 +87,19 @@
       </thead>
       <tbody class="hakumi-table-tbody">
         <% if display_rows.any? %>
-          <% display_rows.each_with_index do |row_data, index| %>
-            <% row = row_data[:row] %>
-            <% depth = row_data[:depth] %>
-            <% row_key = row_key_for(row, index) %>
+            <% display_rows.each_with_index do |row_data, index| %>
+              <% row = row_data[:row] %>
+              <% depth = row_data[:depth] %>
+              <% row_key = row_key_for(row, index) %>
             <tr class="<%= row_classes(row, index, row_key) %>"
                 data-hakumi--table-target="row"
                 data-row-key="<%= row_key %>"
                 data-row-type="data">
               <% leaf_columns.each do |column| %>
-                <% raw_value = column[:data_index] ? value_from_row(row, column[:data_index]) : nil %>
+                <% raw_value = column.data_index ? row.value(column.data_index) : nil %>
                 <% attrs = cell_attributes(column, row, index, depth, row_key, raw_value) %>
                 <% next if attrs[:colspan] == 0 || attrs[:rowspan] == 0 %>
-                <td <%= tag.attributes(attrs) %> data-sort-value="<%= raw_value %>">
+                <td <%= tag.attributes(attrs) %>>
                   <% content = cell_content(column, row, index, raw_value) %>
                   <% if content.is_a?(Hash) && content[:drag_handle] %>
                     <span class="hakumi-table-drag-handle" data-hakumi--table-target="dragHandle">
@@ -127,7 +118,7 @@
                       <%= "checked" if content[:checked] %>>
                   <% elsif content.is_a?(Hash) && content[:row_key] %>
                     <button type="button"
-                            class="hakumi-table-expand-button <%= 'is-expanded' if content[:expanded] %>"
+                            class="hakumi-table-expand-button <%= 'hakumi-table-expand-button-expanded' if content[:expanded] %>"
                             data-hakumi--table-target="expandToggle"
                             data-action="click->hakumi--table#toggleExpand"
                             data-row-key="<%= content[:row_key] %>"
@@ -142,7 +133,7 @@
             </tr>
             <% if expandable? %>
               <% expanded_content = expanded_row_content(row, index) %>
-              <tr class="hakumi-table-expanded-row <%= "is-expanded" if expanded_row?(row_key) %>"
+              <tr class="hakumi-table-expanded-row <%= "hakumi-table-row-expanded" if expanded_row?(row_key) %>"
                   data-row-key="<%= row_key %>"
                   data-row-type="expanded"
                   <%= "hidden" unless expanded_row?(row_key) %>>