hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -0,0 +1,518 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Configs
+      InputValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::ConfigInputValue }
+      InputHash = T.type_alias { HakumiComponents::Table::DefinitionTypes::ConfigInputHash }
+
+      class Editable
+        extend T::Sig
+
+        MODES = T.let(%i[cell row].freeze, T::Array[Symbol])
+        TRIGGERS = T.let(%i[click dblclick].freeze, T::Array[Symbol])
+        InputScalar = T.type_alias { T.any(T::Boolean, Types::HtmlKey) }
+        Payload = T.type_alias { T::Hash[Symbol, Types::HtmlKey] }
+        Input = T.type_alias { T.nilable(T.any(InputScalar, InputHash, HakumiComponents::Table::Configs::Editable)) }
+
+        sig { params(mode: Symbol, trigger: Symbol).void }
+        def initialize(mode: :cell, trigger: :click)
+          @mode = T.let(MODES.include?(mode) ? mode : :cell, Symbol)
+          @trigger = T.let(TRIGGERS.include?(trigger) ? trigger : :click, Symbol)
+        end
+
+        sig { returns(Symbol) }
+        attr_reader :mode, :trigger
+
+        sig { returns(Payload) }
+        def to_h
+          { mode: @mode, trigger: @trigger }
+        end
+
+        sig { params(value: Input).returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+        def self.coerce(value)
+          return nil if value.nil? || value == false
+          return new if value == true
+          return value if value.is_a?(HakumiComponents::Table::Configs::Editable)
+
+          if value.is_a?(String) || value.is_a?(Symbol)
+            return new(mode: normalize_mode(value))
+          end
+
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.deep_symbolize_keys
+          new(
+            mode: normalize_mode(normalized[:mode]),
+            trigger: normalize_trigger(normalized[:trigger])
+          )
+        end
+
+        class << self
+          extend T::Sig
+
+          private
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(Symbol) }
+          def normalize_mode(value)
+            mode = value.to_s.downcase.to_sym
+            MODES.include?(mode) ? mode : :cell
+          end
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(Symbol) }
+          def normalize_trigger(value)
+            trigger = value.to_s.downcase.to_sym
+            TRIGGERS.include?(trigger) ? trigger : :click
+          end
+        end
+      end
+
+      class ColumnEditable
+        extend T::Sig
+
+        INPUT_TYPES = T.let(%i[text number textarea select].freeze, T::Array[Symbol])
+        Payload = T.type_alias { T::Hash[Symbol, Symbol] }
+        Input = T.type_alias do
+            T.nilable(T.any(
+              T::Boolean,
+              InputHash,
+              HakumiComponents::Table::Configs::ColumnEditable
+            ))
+          end
+
+        sig { params(input_type: Symbol).void }
+        def initialize(input_type: :text)
+          @input_type = T.let(INPUT_TYPES.include?(input_type) ? input_type : :text, Symbol)
+        end
+
+        sig { returns(Symbol) }
+        attr_reader :input_type
+
+        sig { returns(Payload) }
+        def to_h
+          { input_type: @input_type }
+        end
+
+        sig { params(value: Input).returns(T.nilable(HakumiComponents::Table::Configs::ColumnEditable)) }
+        def self.coerce(value)
+          return nil if value.nil? || value == false
+          return new if value == true
+          return value if value.is_a?(HakumiComponents::Table::Configs::ColumnEditable)
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.deep_symbolize_keys
+          input_type = normalized[:input_type] || normalized[:type]
+          new(input_type: normalize_input_type(input_type))
+        end
+
+        class << self
+          extend T::Sig
+
+          private
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(Symbol) }
+          def normalize_input_type(value)
+            input_type = value.to_s.downcase.to_sym
+            INPUT_TYPES.include?(input_type) ? input_type : :text
+          end
+        end
+      end
+
+      class RowSelection
+        extend T::Sig
+
+        TYPES = T.let(%i[checkbox radio].freeze, T::Array[Symbol])
+        Input = T.type_alias { T.nilable(InputHash) }
+
+        sig do
+          params(
+            type: Symbol,
+            selected_row_keys: T::Array[String],
+            preserve_selected_row_keys: T::Boolean,
+            selections_enabled: T::Boolean
+          ).void
+        end
+        def initialize(type:, selected_row_keys:, preserve_selected_row_keys:, selections_enabled:)
+          @type = T.let(type, Symbol)
+          @selected_row_keys = T.let(selected_row_keys, T::Array[String])
+          @preserve_selected_row_keys = T.let(preserve_selected_row_keys, T::Boolean)
+          @selections_enabled = T.let(selections_enabled, T::Boolean)
+          validate!
+        end
+
+        sig { returns(Symbol) }
+        attr_reader :type
+
+        sig { returns(T::Array[String]) }
+        attr_reader :selected_row_keys
+
+        sig { returns(T::Boolean) }
+        attr_reader :preserve_selected_row_keys, :selections_enabled
+
+        sig { params(value: Input).returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+        def self.coerce(value)
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.deep_symbolize_keys
+          selected_row_keys = Array(normalized[:selected_row_keys] || normalized[:selectedRowKeys]).map(&:to_s)
+
+          new(
+            type: normalize_type(normalized[:type]),
+            selected_row_keys: selected_row_keys,
+            preserve_selected_row_keys: normalized[:preserve_selected_row_keys] == true || normalized[:preserveSelectedRowKeys] == true,
+            selections_enabled: !!normalized[:selections]
+          )
+        end
+
+        class << self
+          extend T::Sig
+
+          private
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(Symbol) }
+          def normalize_type(value)
+            return :checkbox if value.nil?
+
+            value.to_s.downcase.to_sym
+          end
+        end
+
+        private
+
+        sig { void }
+        def validate!
+          return if TYPES.include?(@type)
+
+          raise ArgumentError, "row_selection type must be one of #{TYPES.inspect}, got #{@type.inspect}"
+        end
+      end
+
+      class Expandable
+        extend T::Sig
+
+        Input = T.type_alias { T.nilable(InputHash) }
+        RowRenderer = T.type_alias { T.nilable(Proc) }
+
+        sig do
+          params(
+            show_expand_column: T::Boolean,
+            expanded_row_keys: T::Array[String],
+            expanded_row_render: RowRenderer
+          ).void
+        end
+        def initialize(show_expand_column:, expanded_row_keys:, expanded_row_render:)
+          @show_expand_column = T.let(show_expand_column, T::Boolean)
+          @expanded_row_keys = T.let(expanded_row_keys, T::Array[String])
+          @expanded_row_render = T.let(expanded_row_render, RowRenderer)
+        end
+
+        sig { returns(T::Boolean) }
+        attr_reader :show_expand_column
+
+        sig { returns(T::Array[String]) }
+        attr_reader :expanded_row_keys
+
+        sig { returns(RowRenderer) }
+        attr_reader :expanded_row_render
+
+        sig { params(row_key: Types::HtmlKey).returns(T::Boolean) }
+        def expanded_row?(row_key)
+          @expanded_row_keys.include?(row_key.to_s)
+        end
+
+        sig { params(value: Input).returns(T.nilable(HakumiComponents::Table::Configs::Expandable)) }
+        def self.coerce(value)
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.deep_symbolize_keys
+          expanded_row_keys = Array(
+            normalized[:expanded_row_keys] ||
+            normalized[:expandedRowKeys] ||
+            normalized[:default_expanded_row_keys] ||
+            normalized[:defaultExpandedRowKeys]
+          ).map(&:to_s)
+
+          expanded_row_render = normalized[:expanded_row_render]
+          expanded_row_render = nil unless expanded_row_render.is_a?(Proc)
+
+          new(
+            show_expand_column: normalized[:show_expand_column] != false,
+            expanded_row_keys: expanded_row_keys,
+            expanded_row_render: expanded_row_render
+          )
+        end
+      end
+
+      class RowDrag
+        extend T::Sig
+
+        Input = T.type_alias { T.nilable(T.any(T::Boolean, Types::HtmlKey, InputHash, HakumiComponents::Table::Configs::RowDrag)) }
+
+        sig { params(enabled: T::Boolean, handle: T::Boolean).void }
+        def initialize(enabled:, handle:)
+          @enabled = T.let(enabled, T::Boolean)
+          @handle = T.let(handle, T::Boolean)
+        end
+
+        sig { returns(T::Boolean) }
+        attr_reader :enabled, :handle
+
+        sig { params(value: Input).returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+        def self.coerce(value)
+          return nil if value.nil? || value == false
+          return value if value.is_a?(HakumiComponents::Table::Configs::RowDrag)
+
+          case value
+          when true
+            new(enabled: true, handle: false)
+          when :handle
+            new(enabled: true, handle: true)
+          when Hash
+            normalized = value.deep_symbolize_keys
+            new(
+              enabled: normalized.fetch(:enabled, true) == true,
+              handle: normalized.fetch(:handle, false) == true
+            )
+          end
+        end
+      end
+
+      class Pagination
+        extend T::Sig
+
+        ShowTotal = T.type_alias { HakumiComponents::Pagination::Component::ShowTotal }
+        Value = T.type_alias { T.nilable(T.any(ViewComponent::Base, HakumiComponents::Table::Configs::Pagination)) }
+        Input = T.type_alias { T.nilable(T.any(ViewComponent::Base, InputHash, HakumiComponents::Table::Configs::Pagination)) }
+
+        sig do
+          params(
+            total: Integer,
+            current: Integer,
+            page_size: Integer,
+            size: Symbol,
+            align: Symbol,
+            simple: T::Boolean,
+            show_size_changer: T.nilable(T::Boolean),
+            show_quick_jumper: T::Boolean,
+            show_total: ShowTotal,
+            page_size_options: T::Array[Integer],
+            hide_on_single_page: T::Boolean,
+            prev_text: T.nilable(String),
+            next_text: T.nilable(String),
+            href: T.nilable(String),
+            page_param: Symbol,
+            per_page_param: Symbol,
+            turbo_frame: T.nilable(String),
+            turbo_action: T.nilable(String),
+            preserve_params: T.nilable(String),
+            sort_field_param: T.nilable(String),
+            sort_order_param: T.nilable(String),
+            server_side: T::Boolean
+          ).void
+        end
+        def initialize(
+          total:,
+          current: 1,
+          page_size: 10,
+          size: :default,
+          align: :start,
+          simple: false,
+          show_size_changer: nil,
+          show_quick_jumper: false,
+          show_total: nil,
+          page_size_options: HakumiComponents::Pagination::Component::DEFAULT_PAGE_SIZE_OPTIONS,
+          hide_on_single_page: false,
+          prev_text: nil,
+          next_text: nil,
+          href: nil,
+          page_param: :page,
+          per_page_param: :per_page,
+          turbo_frame: nil,
+          turbo_action: nil,
+          preserve_params: nil,
+          sort_field_param: nil,
+          sort_order_param: nil,
+          server_side: false
+        )
+          @total = T.let(total, Integer)
+          @current = T.let(current, Integer)
+          @page_size = T.let(page_size, Integer)
+          @size = T.let(size, Symbol)
+          @align = T.let(align, Symbol)
+          @simple = T.let(simple, T::Boolean)
+          @show_size_changer = T.let(show_size_changer, T.nilable(T::Boolean))
+          @show_quick_jumper = T.let(show_quick_jumper, T::Boolean)
+          @show_total = T.let(show_total, ShowTotal)
+          @page_size_options = T.let(page_size_options, T::Array[Integer])
+          @hide_on_single_page = T.let(hide_on_single_page, T::Boolean)
+          @prev_text = T.let(prev_text, T.nilable(String))
+          @next_text = T.let(next_text, T.nilable(String))
+          @href = T.let(href, T.nilable(String))
+          @page_param = T.let(page_param, Symbol)
+          @per_page_param = T.let(per_page_param, Symbol)
+          @turbo_frame = T.let(turbo_frame, T.nilable(String))
+          @turbo_action = T.let(turbo_action, T.nilable(String))
+          @preserve_params = T.let(preserve_params, T.nilable(String))
+          @sort_field_param = T.let(sort_field_param, T.nilable(String))
+          @sort_order_param = T.let(sort_order_param, T.nilable(String))
+          @server_side = T.let(server_side, T::Boolean)
+        end
+
+        sig { returns(Integer) }
+        attr_reader :total, :current, :page_size
+
+        sig { returns(Symbol) }
+        attr_reader :size, :align, :page_param, :per_page_param
+
+        sig { returns(T::Boolean) }
+        attr_reader :simple, :show_quick_jumper, :hide_on_single_page, :server_side
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :show_size_changer
+
+        sig { returns(ShowTotal) }
+        attr_reader :show_total
+
+        sig { returns(T::Array[Integer]) }
+        attr_reader :page_size_options
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :prev_text, :next_text, :href, :turbo_frame, :turbo_action, :preserve_params, :sort_field_param, :sort_order_param
+
+        sig { returns(T::Boolean) }
+        def ajax?
+          @href.present? || @server_side
+        end
+
+        sig { returns(HakumiComponents::Pagination::Component) }
+        def build_component
+          HakumiComponents::Pagination::Component.new(
+            total: @total,
+            current: @current,
+            page_size: @page_size,
+            size: @size,
+            align: @align,
+            simple: @simple,
+            show_size_changer: @show_size_changer,
+            show_quick_jumper: @show_quick_jumper,
+            show_total: @show_total,
+            page_size_options: @page_size_options,
+            hide_on_single_page: @hide_on_single_page,
+            prev_text: @prev_text,
+            next_text: @next_text,
+            href: @href,
+            page_param: @page_param,
+            per_page_param: @per_page_param,
+            turbo_frame: @turbo_frame,
+            turbo_action: @turbo_action,
+            preserve_params: @preserve_params
+          )
+        end
+
+        sig { returns(HakumiComponents::Pagination::Component) }
+        def build_ajax_component
+          HakumiComponents::Pagination::Component.new(
+            current: 1,
+            page_size: @page_size,
+            total: 0,
+            show_size_changer: @show_size_changer.nil? ? true : @show_size_changer
+          )
+        end
+
+        sig { params(value: Input, total: Integer).returns(Value) }
+        def self.coerce(value, total:)
+          return nil if value.nil? || value == false
+          return value if value.is_a?(ViewComponent::Base) || value.is_a?(HakumiComponents::Table::Configs::Pagination)
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.deep_symbolize_keys
+          page_size_options = Array(normalized[:page_size_options]).filter_map do |entry|
+            entry.is_a?(Numeric) ? entry.to_i : nil
+          end
+          page_size_options = HakumiComponents::Pagination::Component::DEFAULT_PAGE_SIZE_OPTIONS if page_size_options.empty?
+
+          raw_show_total = T.let(normalized[:show_total], HakumiComponents::Table::DefinitionTypes::RawEntry)
+          show_total = T.let(nil, ShowTotal)
+          if raw_show_total == true || raw_show_total == false || raw_show_total.is_a?(String)
+            show_total = raw_show_total
+          elsif raw_show_total.is_a?(Proc)
+            show_total = lambda do |total_count, range|
+              raw_show_total.call(total_count, range).to_s
+            end
+          end
+
+          preserve_params = T.let(normalized[:preserve_params], HakumiComponents::Table::DefinitionTypes::RawEntry)
+          preserve_params = preserve_params.to_s if preserve_params.is_a?(Symbol)
+          preserve_params = nil unless preserve_params.nil? || preserve_params.is_a?(String)
+
+          total_value = T.let(normalized[:total], HakumiComponents::Table::DefinitionTypes::RawEntry)
+          resolved_total = total_value.is_a?(Numeric) ? total_value.to_i : total
+
+          new(
+            total: resolved_total,
+            current: normalize_integer(normalized[:current] || normalized[:page], fallback: 1),
+            page_size: normalize_integer(normalized[:page_size] || normalized[:pageSize], fallback: 10),
+            size: normalize_symbol(normalized[:size], fallback: :default),
+            align: normalize_symbol(normalized[:align], fallback: :start),
+            simple: normalized[:simple] == true,
+            show_size_changer: normalize_nullable_boolean(normalized[:show_size_changer]),
+            show_quick_jumper: normalized[:show_quick_jumper] == true,
+            show_total: show_total,
+            page_size_options: page_size_options,
+            hide_on_single_page: normalized[:hide_on_single_page] == true,
+            prev_text: normalize_string(normalized[:prev_text]),
+            next_text: normalize_string(normalized[:next_text]),
+            href: normalize_string(normalized[:href]),
+            page_param: normalize_symbol(normalized[:page_param], fallback: :page),
+            per_page_param: normalize_symbol(normalized[:per_page_param], fallback: :per_page),
+            turbo_frame: normalize_string(normalized[:turbo_frame]),
+            turbo_action: normalize_string(normalized[:turbo_action]),
+            preserve_params: preserve_params,
+            sort_field_param: normalize_string(normalized[:sort_field_param]),
+            sort_order_param: normalize_string(normalized[:sort_order_param]),
+            server_side: normalized[:server_side] == true
+          )
+        end
+
+        class << self
+          extend T::Sig
+
+          private
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry, fallback: Integer).returns(Integer) }
+          def normalize_integer(value, fallback:)
+            return value.to_i if value.is_a?(Numeric)
+            return value.to_i if value.is_a?(String) && value.match?(/\A\d+\z/)
+
+            fallback
+          end
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry, fallback: Symbol).returns(Symbol) }
+          def normalize_symbol(value, fallback:)
+            return value if value.is_a?(Symbol)
+            return value.to_sym if value.is_a?(String) && value.present?
+
+            fallback
+          end
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(T::Boolean)) }
+          def normalize_nullable_boolean(value)
+            return true if value == true
+            return false if value == false
+
+            nil
+          end
+
+          sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(String)) }
+          def normalize_string(value)
+            return value if value.is_a?(String)
+            return value.to_s if value.is_a?(Symbol)
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module DefinitionTypes
+      extend T::Sig
+
+      ColumnKey = T.type_alias { Types::HtmlKey }
+      # T.untyped is intentional: column definitions accept any Ruby value (strings,
+      # symbols, procs, arrays, hashes, booleans). Each normalize_* method narrows
+      # this to the specific type it expects.
+      RawEntry = T.type_alias { T.untyped }
+      ComparableValue = T.type_alias { Types::ValidationComparable }
+      PrimitiveValue = T.type_alias { Types::ValidationPrimitive }
+      ScalarList = T.type_alias { T::Array[ComparableValue] }
+      WidthValue = T.type_alias { T.nilable(T.any(String, Numeric)) }
+      SearchValue = T.type_alias { T.nilable(T.any(Types::StringOrSymbol, T::Boolean)) }
+      SorterValue = T.type_alias { SearchValue }
+      SortValue = T.type_alias { T.nilable(T.any(Types::StringOrSymbol, Proc)) }
+      RawCollection = T.type_alias { T::Array[RawEntry] }
+      RawRecord = T.type_alias { T::Hash[ColumnKey, RawEntry] }
+      ConfigInputValue = T.type_alias do
+        T.nilable(T.any(Types::HtmlScalar, Proc, T::Array[T.untyped], T::Hash[Types::HtmlKey, T.untyped]))
+      end
+      ConfigInputHash = T.type_alias { T::Hash[Types::HtmlKey, ConfigInputValue] }
+
+      DefinitionValue = T.type_alias do
+        T.nilable(T.any(
+          PrimitiveValue,
+          Proc,
+          RawCollection,
+          T::Hash[Symbol, RawEntry]
+        ))
+      end
+
+      DefinitionHash = T.type_alias { T::Hash[Symbol, DefinitionValue] }
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class DisplayRows
+      extend T::Sig
+
+      Row = T.type_alias { HakumiComponents::Table::RowRecord }
+      DisplayRow = T.type_alias { { row: Row, depth: Integer } }
+      PaginationValue = T.type_alias { HakumiComponents::Table::Configs::Pagination::Value }
+
+      sig { params(rows: T::Array[Row], pagination: PaginationValue).returns(T::Array[DisplayRow]) }
+      def self.build(rows:, pagination:)
+        new(rows: rows, pagination: pagination).to_a
+      end
+
+      sig { params(rows: T::Array[Row], pagination: PaginationValue).void }
+      def initialize(rows:, pagination:)
+        @rows = T.let(rows, T::Array[Row])
+        @pagination = T.let(pagination, PaginationValue)
+      end
+
+      sig { returns(T::Array[DisplayRow]) }
+      def to_a
+        rows = flatten_tree(@rows)
+        apply_pagination(rows)
+      end
+
+      private
+
+      sig { params(rows: T::Array[Row], depth: Integer).returns(T::Array[DisplayRow]) }
+      def flatten_tree(rows, depth = 0)
+        rows.flat_map do |row|
+          current = T.let({ row: row, depth: depth }, DisplayRow)
+          children = row.children
+          if children.any?
+            [ current, *flatten_tree(children, depth + 1) ]
+          else
+            [ current ]
+          end
+        end
+      end
+
+      sig { params(rows: T::Array[DisplayRow]).returns(T::Array[DisplayRow]) }
+      def apply_pagination(rows)
+        pagination = @pagination
+        return rows unless pagination.is_a?(HakumiComponents::Table::Configs::Pagination)
+        return rows if pagination.ajax?
+
+        start = (pagination.current - 1) * pagination.page_size
+        rows.slice(start, pagination.page_size) || []
+      end
+    end
+  end
+end