hakumi_components 0.1.16.pre → 0.1.17.pre

data/app/components/hakumi/statistic/component.rb

@@ -255,10 +255,6 @@ module Hakumi
           .gsub("ss", seconds.to_s.rjust(2, "0"))
       end
 
-      def cast_boolean(value)
-        ActiveModel::Type::Boolean.new.cast(value)
-      end
-
       def normalize_precision(value)
         return nil if value.nil?
         return value if value.is_a?(Integer)

data/app/components/hakumi/switch/component.html.erb

@@ -1,4 +1,8 @@
 <% 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") %>
+  <% end %>
   <%= content_tag(:label, **wrapper_attributes) do %>
     <%= tag.input(**input_attributes) %>
     <span class="hakumi-switch-handle">

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

@@ -23,7 +23,7 @@ module Hakumi
         errors: [],
         **html_options
       )
-        @name = name || "switch_#{SecureRandom.hex(4)}"
+        @name = name || generate_id("switch")
         @label = label
         @caption = caption
         @checked = checked.nil? ? default_checked : checked
@@ -96,7 +96,6 @@ module Hakumi
           class: [ "hakumi-switch-input", @html_options[:class] ].compact.join(" "),
           checked: @checked ? true : nil,
           disabled: (@disabled || @loading) ? true : nil,
-          required: @required ? true : nil,
           "aria-invalid": has_error? ? "true" : nil,
           "aria-describedby": describedby_ids,
           tabindex: "-1",

data/app/components/hakumi/table/component.rb

@@ -5,6 +5,9 @@ module Hakumi
     # A complex Table component supporting sorting, filtering, selection, expansion, and editing.
     class Component < Hakumi::BaseComponent
       include Concerns::Columns
+      include Concerns::Editable
+      include Concerns::FixedColumns
+      include Concerns::Ellipsis
 
       # @group Configuration Constants
       SIZES = %i[default middle small].freeze
@@ -12,9 +15,6 @@ module Hakumi
       SORT_DIRECTIONS = %i[ascend descend].freeze
       FIXED_SIDES = %i[left right].freeze
       RESPONSIVE_BREAKPOINTS = %i[xs sm md lg xl xxl].freeze
-      EDITABLE_MODES = %i[cell row].freeze
-      EDITABLE_TRIGGERS = %i[click dblclick].freeze
-      EDITABLE_INPUT_TYPES = %i[text number textarea select].freeze
       ROW_BUTTON_ACTIONS = %i[edit save cancel].freeze
 
       # @group Slot Definitions
@@ -538,10 +538,6 @@ module Hakumi
         }
       end
 
-      def fixed_columns?
-        fixed_offsets.present?
-      end
-
       private
 
       def normalize_row_selection!
@@ -575,132 +571,6 @@ module Hakumi
         }.compact.presence
       end
 
-      def cast_boolean(value)
-        ActiveModel::Type::Boolean.new.cast(value)
-      end
-
-      def fixed_offsets
-        @fixed_offsets ||= {}
-      end
-
-      def apply_fixed_column_attributes!(attrs, column, header: false)
-        info = fixed_offsets[column[:key]]
-        return unless info
-
-        attrs[:class] = [ attrs[:class], "hakumi-table-cell-fixed", "hakumi-table-cell-fixed-#{info[:side]}" ].compact.join(" ")
-
-        style_parts = []
-        style_parts << attrs[:style] if attrs[:style].present?
-        style_parts << "position: sticky"
-        style_parts << "#{info[:side]}: #{info[:offset]}px"
-        style_parts << "z-index: #{header ? 3 : 2}"
-        attrs[:style] = style_parts.compact.join("; ")
-
-        attrs[:data] ||= {}
-        attrs[:data][:fixed] = info[:side]
-      end
-
-      def apply_editable_attributes!(attrs, column)
-        payload = cell_editable_payload(column)
-        return unless payload
-
-        attrs[:class] = [ attrs[:class], "hakumi-table-cell-editable" ].compact.join(" ")
-        attrs[:data] ||= {}
-        attrs[:data][:editable] = true
-        attrs[:data][:editableConfig] = payload.to_json
-        attrs[:data][:action] = "click->hakumi--table#editCell"
-      end
-
-      def compute_fixed_offsets(leaf_columns)
-        @fixed_offsets = {}
-        return if leaf_columns.blank?
-
-        left_offset = 0
-        leaf_columns.each do |column|
-          next unless column[:fixed] == :left
-
-          width = fixed_column_width!(column)
-          @fixed_offsets[column[:key]] = { side: :left, offset: left_offset }
-          left_offset += width
-        end
-
-        right_offset = 0
-        leaf_columns.reverse_each do |column|
-          next unless column[:fixed] == :right
-
-          width = fixed_column_width!(column)
-          @fixed_offsets[column[:key]] = { side: :right, offset: right_offset }
-          right_offset += width
-        end
-      end
-
-      def fixed_column_width!(column)
-        width = numeric_width(column[:width])
-        return width if width&.positive?
-
-        raise ArgumentError, "Column #{column[:key] || column[:data_index] || column[:title]} must define a pixel width when fixed"
-      end
-
-      def numeric_width(value)
-        return value.to_f if value.is_a?(Numeric)
-        return nil unless value.is_a?(String)
-
-        stripped = value.strip
-        return stripped.to_f if stripped.match?(/\A[\d.]+\z/)
-
-        match = stripped.match(/\A([\d.]+)px\z/i)
-        match ? match[1].to_f : nil
-      end
-
-      def ellipsis_config(column)
-        column[:ellipsis]
-      end
-
-      def normalize_ellipsis_option(option)
-        return nil if option.nil? || option == false
-
-        if option == true
-          { show_title: true }
-        elsif option.is_a?(Hash)
-          normalized = option.deep_symbolize_keys
-          normalized[:tooltip] = normalize_ellipsis_tooltip_option(normalized[:tooltip])
-          normalized.compact.presence
-        else
-          { tooltip: normalize_ellipsis_tooltip_option(option) }
-        end
-      end
-
-      def normalize_ellipsis_tooltip_option(option)
-        return nil if option.nil? || option == false
-        return {} if option == true
-        return { title: option } if option.is_a?(String)
-        return option.deep_symbolize_keys if option.is_a?(Hash)
-
-        nil
-      end
-
-      def ellipsis_title(config, raw_value, content_fragment)
-        return nil unless config&.dig(:show_title)
-
-        value = raw_value.presence || content_fragment
-        value = value.to_s if value.respond_to?(:to_s)
-        value.present? ? value : nil
-      end
-
-      def ellipsis_tooltip_component(config, raw_value, row, row_index)
-        tooltip = config&.dig(:tooltip)
-        return nil unless tooltip
-
-        options = tooltip.deep_dup
-        title = options.delete(:title)
-        title ||= raw_value
-        title = title.call(row, row_index) if title.respond_to?(:call)
-        title = title.to_s if title.respond_to?(:to_s)
-        return nil if title.blank?
-
-        Hakumi::Tooltip::Component.new(**{ title: title }.merge(options))
-      end
-
       def responsive_classes(column)
         responsive = column[:responsive]
         return [] unless responsive.present?
@@ -823,33 +693,6 @@ module Hakumi
         }
       end
 
-      # Normalizes the table-level editable configuration.
-      # Accepts boolean, symbol (:cell or :row), or hash with options.
-      # Returns nil if editing is disabled, or a hash with normalized options.
-      #
-      # @param value [Boolean, Symbol, Hash, nil] editable configuration
-      # @return [Hash, nil] normalized configuration
-      def normalize_editable(value)
-        return nil if value.nil? || value == false
-
-        case value
-        when true
-          { mode: :cell, trigger: :click }
-        when Symbol
-          mode = EDITABLE_MODES.include?(value) ? value : :cell
-          { mode: mode, trigger: :click }
-        when Hash
-          normalized = value.deep_symbolize_keys
-          mode = normalized[:mode]&.to_sym
-          normalized[:mode] = EDITABLE_MODES.include?(mode) ? mode : :cell
-          trigger = normalized[:trigger]&.to_sym
-          normalized[:trigger] = EDITABLE_TRIGGERS.include?(trigger) ? trigger : :click
-          normalized
-        else
-          nil
-        end
-      end
-
       # Normalizes row drag configuration.
       # Can be: true (drag whole row), :handle (drag via handle only), or Hash with options
       #
@@ -874,44 +717,6 @@ module Hakumi
         end
       end
 
-      # Normalizes column-level editable configuration.
-      # Column editable can override table-level settings.
-      #
-      # @param value [Boolean, Hash, nil] column editable configuration
-      # @return [Hash, nil] normalized configuration
-      def normalize_column_editable(value)
-        return nil if value.nil? || value == false
-        return {} if value == true
-
-        return nil unless value.is_a?(Hash)
-
-        normalized = value.deep_symbolize_keys
-        input_type = normalized[:type]&.to_sym || normalized[:input_type]&.to_sym
-        normalized[:input_type] = EDITABLE_INPUT_TYPES.include?(input_type) ? input_type : :text
-        normalized.except(:type)
-      end
-
-      def normalize_should_cell_update(value)
-        case value
-        when Symbol
-          value.to_s
-        when String
-          value.strip.presence
-        else
-          nil
-        end
-      end
-
-      # Returns JSON configuration for the table-level editable settings
-      # to be passed to the Stimulus controller.
-      #
-      # @return [String, nil] JSON string or nil if not editable
-      def editable_config_json
-        return nil unless @editable
-
-        @editable.to_json
-      end
-
       def columns_config_json
         leaf_columns.map do |col|
           {
@@ -921,37 +726,6 @@ module Hakumi
           }.compact
         end.to_json
       end
-
-      # Returns the editable payload for a specific cell/column.
-      # Used to add data-editable-config attribute to editable cells.
-      #
-      # @param column [Hash] the column definition
-      # @return [Hash, nil] editable configuration for the cell
-      def cell_editable_payload(column)
-        return nil if column[:selection] || column[:expand]
-        return nil unless column[:data_index]
-
-        column_config = column[:editable]
-
-        # Column must explicitly opt-in to be editable
-        return nil if column_config.nil? || column_config == false
-
-        # Merge table-level and column-level config
-        base_config = @editable&.dup || {}
-        base_config.merge!(column_config) if column_config.is_a?(Hash)
-
-        base_config[:data_index] = column[:data_index]
-        base_config[:key] = column[:key]
-        base_config
-      end
-
-      def apply_should_cell_update_attributes!(attrs, column)
-        hook = column[:should_cell_update]
-        return unless hook.present?
-
-        attrs[:data] ||= {}
-        attrs[:data][:should_cell_update] = hook
-      end
     end
   end
 end

data/app/components/hakumi/table/concerns/columns.rb

@@ -66,7 +66,7 @@ module Hakumi
           normalized = column.deep_symbolize_keys
           return nil if normalized[:hidden]
 
-          normalized[:key] ||= normalized[:data_index] || SecureRandom.hex(4)
+          normalized[:key] ||= normalized[:data_index] || generate_id("col")
           normalized[:ellipsis] = normalize_ellipsis_option(normalized[:ellipsis])
           normalized[:responsive] = normalize_responsive_breakpoints(normalized[:responsive])
           normalized[:width] = dimension_to_css(normalized[:width])

data/app/components/hakumi/table/concerns/editable.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Hakumi
+  module Table
+    module Concerns
+      # Editable cell and row functionality for Table component
+      module Editable
+        extend ActiveSupport::Concern
+
+        EDITABLE_MODES = %i[cell row].freeze
+        EDITABLE_TRIGGERS = %i[click dblclick].freeze
+        EDITABLE_INPUT_TYPES = %i[text number textarea select].freeze
+
+        # Returns JSON configuration for the table-level editable settings
+        # to be passed to the Stimulus controller.
+        #
+        # @return [String, nil] JSON string or nil if not editable
+        def editable_config_json
+          return nil unless @editable
+
+          @editable.to_json
+        end
+
+        private
+
+        # Normalizes the table-level editable configuration.
+        # Accepts boolean, symbol (:cell or :row), or hash with options.
+        # Returns nil if editing is disabled, or a hash with normalized options.
+        #
+        # @param value [Boolean, Symbol, Hash, nil] editable configuration
+        # @return [Hash, nil] normalized configuration
+        def normalize_editable(value)
+          return nil if value.nil? || value == false
+
+          case value
+          when true
+            { mode: :cell, trigger: :click }
+          when Symbol
+            mode = EDITABLE_MODES.include?(value) ? value : :cell
+            { mode: mode, trigger: :click }
+          when Hash
+            normalized = value.deep_symbolize_keys
+            mode = normalized[:mode]&.to_sym
+            normalized[:mode] = EDITABLE_MODES.include?(mode) ? mode : :cell
+            trigger = normalized[:trigger]&.to_sym
+            normalized[:trigger] = EDITABLE_TRIGGERS.include?(trigger) ? trigger : :click
+            normalized
+          end
+        end
+
+        # Normalizes column-level editable configuration.
+        # Column editable can override table-level settings.
+        #
+        # @param value [Boolean, Hash, nil] column editable configuration
+        # @return [Hash, nil] normalized configuration
+        def normalize_column_editable(value)
+          return nil if value.nil? || value == false
+          return {} if value == true
+          return nil unless value.is_a?(Hash)
+
+          normalized = value.deep_symbolize_keys
+          input_type = normalized[:type]&.to_sym || normalized[:input_type]&.to_sym
+          normalized[:input_type] = EDITABLE_INPUT_TYPES.include?(input_type) ? input_type : :text
+          normalized.except(:type)
+        end
+
+        def normalize_should_cell_update(value)
+          case value
+          when Symbol
+            value.to_s
+          when String
+            value.strip.presence
+          end
+        end
+
+        # Applies editable attributes to cell
+        def apply_editable_attributes!(attrs, column)
+          payload = cell_editable_payload(column)
+          return unless payload
+
+          attrs[:class] = [ attrs[:class], "hakumi-table-cell-editable" ].compact.join(" ")
+          attrs[:data] ||= {}
+          attrs[:data][:editable] = true
+          attrs[:data][:editableConfig] = payload.to_json
+          attrs[:data][:action] = "click->hakumi--table#editCell"
+        end
+
+        def apply_should_cell_update_attributes!(attrs, column)
+          hook = column[:should_cell_update]
+          return unless hook.present?
+
+          attrs[:data] ||= {}
+          attrs[:data][:should_cell_update] = hook
+        end
+
+        # Returns the editable payload for a specific cell/column.
+        # Used to add data-editable-config attribute to editable cells.
+        #
+        # @param column [Hash] the column definition
+        # @return [Hash, nil] editable configuration for the cell
+        def cell_editable_payload(column)
+          return nil if column[:selection] || column[:expand]
+          return nil unless column[:data_index]
+
+          column_config = column[:editable]
+
+          # Column must explicitly opt-in to be editable
+          return nil if column_config.nil? || column_config == false
+
+          # Merge table-level and column-level config
+          base_config = @editable&.dup || {}
+          base_config.merge!(column_config) if column_config.is_a?(Hash)
+
+          base_config[:data_index] = column[:data_index]
+          base_config[:key] = column[:key]
+          base_config
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi/table/concerns/ellipsis.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Hakumi
+  module Table
+    module Concerns
+      # Text ellipsis and tooltip handling for Table cells
+      module Ellipsis
+        extend ActiveSupport::Concern
+
+        private
+
+        def ellipsis_config(column)
+          column[:ellipsis]
+        end
+
+        def normalize_ellipsis_option(option)
+          return nil if option.nil? || option == false
+
+          if option == true
+            { show_title: true }
+          elsif option.is_a?(Hash)
+            normalized = option.deep_symbolize_keys
+            normalized[:tooltip] = normalize_ellipsis_tooltip_option(normalized[:tooltip])
+            normalized.compact.presence
+          else
+            { tooltip: normalize_ellipsis_tooltip_option(option) }
+          end
+        end
+
+        def normalize_ellipsis_tooltip_option(option)
+          return nil if option.nil? || option == false
+          return {} if option == true
+          return { title: option } if option.is_a?(String)
+          return option.deep_symbolize_keys if option.is_a?(Hash)
+
+          nil
+        end
+
+        def ellipsis_title(config, raw_value, content_fragment)
+          return nil unless config&.dig(:show_title)
+
+          value = raw_value.presence || content_fragment
+          value = value.to_s if value.respond_to?(:to_s)
+          value.present? ? value : nil
+        end
+
+        def ellipsis_tooltip_component(config, raw_value, row, row_index)
+          tooltip = config&.dig(:tooltip)
+          return nil unless tooltip
+
+          options = tooltip.deep_dup
+          title = options.delete(:title)
+          title ||= raw_value
+          title = title.call(row, row_index) if title.respond_to?(:call)
+          title = title.to_s if title.respond_to?(:to_s)
+          return nil if title.blank?
+
+          Hakumi::Tooltip::Component.new(**{ title: title }.merge(options))
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi/table/concerns/fixed_columns.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Hakumi
+  module Table
+    module Concerns
+      # Fixed (sticky) column positioning for Table component
+      module FixedColumns
+        extend ActiveSupport::Concern
+
+        # Check if table has any fixed columns
+        def fixed_columns?
+          fixed_offsets.present?
+        end
+
+        private
+
+        def fixed_offsets
+          @fixed_offsets ||= {}
+        end
+
+        # Applies fixed column positioning attributes to cell
+        def apply_fixed_column_attributes!(attrs, column, header: false)
+          info = fixed_offsets[column[:key]]
+          return unless info
+
+          attrs[:class] = [ attrs[:class], "hakumi-table-cell-fixed", "hakumi-table-cell-fixed-#{info[:side]}" ].compact.join(" ")
+
+          style_parts = Array.new
+          style_parts << attrs[:style] if attrs[:style].present?
+          style_parts << "position: sticky"
+          style_parts << "#{info[:side]}: #{info[:offset]}px"
+          style_parts << "z-index: #{header ? 3 : 2}"
+          attrs[:style] = style_parts.compact.join("; ")
+
+          attrs[:data] ||= {}
+          attrs[:data][:fixed] = info[:side]
+        end
+
+        # Compute fixed column offsets from left and right
+        def compute_fixed_offsets(leaf_columns)
+          @fixed_offsets = {}
+          return if leaf_columns.blank?
+
+          # Calculate left fixed columns
+          left_offset = 0
+          leaf_columns.each do |column|
+            next unless column[:fixed] == :left
+
+            width = fixed_column_width!(column)
+            @fixed_offsets[column[:key]] = { side: :left, offset: left_offset }
+            left_offset += width
+          end
+
+          # Calculate right fixed columns (from right to left)
+          right_offset = 0
+          leaf_columns.reverse_each do |column|
+            next unless column[:fixed] == :right
+
+            width = fixed_column_width!(column)
+            @fixed_offsets[column[:key]] = { side: :right, offset: right_offset }
+            right_offset += width
+          end
+        end
+
+        def fixed_column_width!(column)
+          width = numeric_width(column[:width])
+          return width if width&.positive?
+
+          raise ArgumentError, "Column #{column[:key] || column[:data_index] || column[:title]} must define a pixel width when fixed"
+        end
+
+        def numeric_width(value)
+          case value
+          when Integer, Float
+            value.to_f
+          when String
+            stripped = value.strip
+            return stripped.to_f if stripped.match?(/\A[\d.]+\z/)
+
+            match = stripped.match(/\A([\d.]+)px\z/i)
+            match ? match[1].to_f : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -196,10 +196,6 @@ module Hakumi
         }
       end
 
-      def cast_boolean(value)
-        ActiveModel::Type::Boolean.new.cast(value)
-      end
-
       def normalize_string(value)
         return nil if value.nil?
 

data/app/controllers/{hakumi_components → hakumi}/components_controller.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module HakumiComponents
+module Hakumi
   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
 
@@ -16,7 +16,7 @@ module HakumiComponents
       raise ActionController::RoutingError, "Not Found" unless COMPONENTS.include?(component)
 
       handler = ComponentHandler.new(component, params)
-      html = render_to_string(partial: "hakumi_components/#{component}", formats: [ :html ], locals: handler.locals)
+      html = render_to_string(partial: "hakumi/#{component}", formats: [ :html ], locals: handler.locals)
 
       respond_to do |format|
         format.html { render html: html, layout: false }