hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Table
-    module Concerns
-      # Column normalization and management for Table component
-      module Columns
-        extend ActiveSupport::Concern
-
-        # Get all leaf columns (columns without children)
-        def leaf_columns
-          @leaf_columns ||= flatten_leaf_columns(normalized_columns)
-        end
-
-        # Count of leaf columns (minimum 1)
-        def leaf_column_count
-          [ leaf_columns.size, 1 ].max
-        end
-
-        # Check if table has selection column
-        def selection_column?
-          @row_selection.present?
-        end
-
-        # Check if table has expandable rows
-        def expandable?
-          @expandable.present?
-        end
-
-        # Check if table has expand column
-        def expand_column?
-          expandable? && @expandable[:show_expand_column] != false
-        end
-
-        # Get normalized columns with special columns inserted
-        def normalized_columns
-          @normalized_columns ||= begin
-            columns = normalize_columns(columns_data)
-            columns = insert_drag_handle_column(columns)
-            columns = insert_selection_column(columns)
-            columns = insert_expand_column(columns)
-            columns = columns.compact
-            compute_fixed_offsets(flatten_leaf_columns(columns))
-            columns
-          end
-        end
-
-        private
-
-        # Normalize an array of column definitions
-        def normalize_columns(columns)
-          Array(columns).filter_map do |column|
-            column = column.public_send(:to_h) if column.respond_to?(:to_h)
-            if column == Hakumi::Table::Component::SELECTION_COLUMN
-              selection_column_definition
-            elsif column == Hakumi::Table::Component::EXPAND_COLUMN
-              expand_column_definition
-            elsif column.is_a?(Hash)
-              normalize_column(column)
-            end
-          end
-        end
-
-        # Normalize a single column definition
-        def normalize_column(column)
-          normalized = column.deep_symbolize_keys
-          return nil if normalized[:hidden]
-
-          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])
-          normalized[:fixed] = normalized[:fixed]&.to_sym if normalized[:fixed]
-          normalized[:fixed] = nil unless Hakumi::Table::Component::FIXED_SIDES.include?(normalized[:fixed])
-          normalized[:editable] = normalize_column_editable(normalized[:editable])
-          normalized[:should_cell_update] = normalize_should_cell_update(normalized[:should_cell_update])
-          if normalized[:children]
-            normalized[:children] = normalize_columns(normalized[:children])
-          end
-          normalized
-        end
-
-        # Insert drag handle column if needed
-        def insert_drag_handle_column(columns)
-          return columns unless drag_handle_column?
-
-          if columns.any? { |col| col.is_a?(Hash) && col[:drag_handle] }
-            columns
-          else
-            [ drag_handle_column_definition, *columns ]
-          end
-        end
-
-        # Insert selection column if needed
-        def insert_selection_column(columns)
-          return columns unless selection_column?
-
-          if columns.any? { |col| col.is_a?(Hash) && col[:selection] }
-            columns
-          elsif columns.any? { |col| col == Hakumi::Table::Component::SELECTION_COLUMN }
-            columns.map { |col| col == Hakumi::Table::Component::SELECTION_COLUMN ? selection_column_definition : col }
-          else
-            [ selection_column_definition, *columns ]
-          end
-        end
-
-        # Insert expand column if needed
-        def insert_expand_column(columns)
-          return columns unless expand_column?
-
-          if columns.any? { |col| col.is_a?(Hash) && col[:expand] }
-            columns
-          elsif columns.any? { |col| col == Hakumi::Table::Component::EXPAND_COLUMN }
-            columns.map { |col| col == Hakumi::Table::Component::EXPAND_COLUMN ? expand_column_definition : col }
-          else
-            [ expand_column_definition, *columns ]
-          end
-        end
-
-        # Definition for selection column
-        def selection_column_definition
-          {
-            key: "__selection__",
-            title: "",
-            selection: true,
-            width: "48px",
-            align: :center
-          }
-        end
-
-        # Definition for expand column
-        def expand_column_definition
-          {
-            key: "__expand__",
-            title: "",
-            expand: true,
-            width: "48px",
-            align: :center
-          }
-        end
-
-        # Check if drag handle column should be added
-        def drag_handle_column?
-          @row_drag&.dig(:handle)
-        end
-
-        # Definition for drag handle column
-        def drag_handle_column_definition
-          {
-            key: "__drag__",
-            title: "",
-            drag_handle: true,
-            width: "48px",
-            align: :center
-          }
-        end
-
-        # Get first data column (non-special column)
-        def first_data_column
-          @first_data_column ||= leaf_columns.find { |col| !col[:selection] && !col[:expand] }
-        end
-
-        # Recursively flatten all leaf columns
-        def flatten_leaf_columns(columns)
-          columns.flat_map do |column|
-            children = column[:children]
-            if children.is_a?(Array) && children.present?
-              flatten_leaf_columns(children)
-            else
-              [ column ]
-            end
-          end
-        end
-
-        # Count leaf columns recursively
-        def leaf_count(columns)
-          columns.sum do |column|
-            children = column[:children]
-            children.is_a?(Array) && children.present? ? leaf_count(children) : 1
-          end
-        end
-
-        # Calculate maximum depth of column hierarchy
-        def max_depth(columns, depth = 1)
-          columns.map do |column|
-            children = column[:children]
-            if children.is_a?(Array) && children.present?
-              max_depth(children, depth + 1)
-            else
-              depth
-            end
-          end.max || depth
-        end
-
-        # Build header rows for rendering
-        def build_header_rows(columns)
-          depth = max_depth(columns)
-          rows = Array.new(depth) { [] }
-          build_rows_recursive(columns, 0, rows, depth)
-          rows
-        end
-
-        # Recursively build header rows
-        def build_rows_recursive(columns, level, rows, max_depth)
-          columns.each do |column|
-            children = column[:children]
-            if children.is_a?(Array) && children.present?
-              col_span = leaf_count(children)
-              rows[level] << { column: column, col_span: col_span, row_span: 1 }
-              build_rows_recursive(children, level + 1, rows, max_depth)
-            else
-              rows[level] << { column: column, col_span: 1, row_span: max_depth - level }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

@@ -1,87 +0,0 @@
-# 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/tabs/component.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Tabs
-    class Component < Hakumi::BaseComponent
-      TYPES = %i[line card editable_card].freeze
-      SIZES = %i[large middle small].freeze
-      TAB_POSITIONS = %i[top bottom left right].freeze
-      INDICATOR_ALIGNS = %i[start center end].freeze
-
-      renders_many :items, ->(
-        key:,
-        label: nil,
-        icon: nil,
-        disabled: false,
-        closable: nil,
-        close_icon: nil,
-        force_render: false,
-        **options,
-        &block
-      ) do
-        item = Hakumi::Tabs::Item::Component.new(
-          key: key,
-          label: label,
-          icon: icon,
-          disabled: disabled,
-          closable: closable.nil? ? (@type == :editable_card) : closable,
-          close_icon: close_icon,
-          force_render: force_render,
-          parent: self,
-          **options
-        )
-        item.content = capture(&block) if block
-        item
-      end
-
-      def initialize(
-        active_key: nil,
-        default_active_key: nil,
-        type: :line,
-        size: :middle,
-        tab_position: :top,
-        centered: false,
-        animated: true,
-        indicator: nil,
-        tab_bar_gutter: nil,
-        tab_bar_extra_content_left: nil,
-        tab_bar_extra_content_right: nil,
-        add_icon: nil,
-        hide_add: false,
-        destroy_inactive_tab_pane: false,
-        **html_options
-      )
-        @active_key = active_key
-        @default_active_key = default_active_key
-        @type = type
-        @size = size
-        @tab_position = tab_position
-        @centered = centered
-        @animated = animated
-        @indicator = indicator || {}
-        @tab_bar_gutter = tab_bar_gutter
-        @tab_bar_extra_content_left = tab_bar_extra_content_left
-        @tab_bar_extra_content_right = tab_bar_extra_content_right
-        @add_icon = add_icon
-        @hide_add = hide_add
-        @destroy_inactive_tab_pane = destroy_inactive_tab_pane
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      attr_reader :type, :size, :tab_position, :centered, :animated, :indicator,
-                  :tab_bar_gutter, :tab_bar_extra_content_left,
-                  :tab_bar_extra_content_right, :add_icon, :hide_add, :destroy_inactive_tab_pane
-
-      def tabs_classes
-        class_names(
-          "tabs",
-          {
-            @type => @type != :line,
-            @size => @size != :middle,
-            @tab_position => @tab_position != :top,
-            centered: @centered
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def vertical?
-        %i[left right].include?(@tab_position)
-      end
-
-      def editable?
-        @type == :editable_card
-      end
-
-      def initial_active_key
-        @active_key || @default_active_key
-      end
-
-      def indicator_size
-        @indicator[:size]
-      end
-
-      def indicator_align
-        @indicator[:align] || :center
-      end
-
-      def wrapper_attributes
-        base_attrs = {
-          class: tabs_classes,
-          data: stimulus_data
-        }
-        merge_attributes(base_attrs, @html_options.except(:class))
-      end
-
-      def stimulus_controller
-        "hakumi--tabs"
-      end
-
-      def stimulus_data
-        data = {
-          controller: stimulus_controller,
-          "#{stimulus_controller}-active-key-value" => initial_active_key,
-          "#{stimulus_controller}-tab-position-value" => @tab_position.to_s,
-          "#{stimulus_controller}-indicator-align-value" => indicator_align.to_s
-        }
-
-        data["#{stimulus_controller}-indicator-size-value"] = indicator_size if indicator_size
-        if editable?
-          data["#{stimulus_controller}-tab-template-value"] = tab_template_html
-          data["#{stimulus_controller}-pane-template-value"] = pane_template_html
-          data["#{stimulus_controller}-close-button-template-value"] = close_button_template_html
-        end
-
-        data
-      end
-
-      def tab_template_html
-        # Template for dynamically added tabs - uses {{key}}, {{label}}, {{closeButton}} placeholders
-        '<div class="hakumi-tabs-tab" data-key="{{key}}" data-hakumi--tabs-target="tab" data-action="click->hakumi--tabs#selectTab"><div class="hakumi-tabs-tab-btn"><span class="hakumi-tabs-tab-label">{{label}}</span></div>{{closeButton}}</div>'.dup.force_encoding("UTF-8")
-      end
-
-      def pane_template_html
-        '<div class="hakumi-tabs-tabpane hakumi-tabs-tabpane-hidden" data-key="{{key}}" data-hakumi--tabs-target="pane" aria-hidden="true">{{content}}</div>'.dup.force_encoding("UTF-8")
-      end
-
-      def close_button_template_html
-        @close_button_template_html ||= ApplicationController.render(
-          Hakumi::Button::Component.new(
-            type: :text,
-            size: :small,
-            icon: :close,
-            class: "hakumi-tabs-tab-remove",
-            aria: { label: "Remove tab" },
-            data: { action: "click->hakumi--tabs#removeTab", key: "{{key}}" }
-          ),
-          layout: false
-        ).strip
-      end
-
-      def nav_list_style
-        styles = []
-        styles << "--tab-bar-gutter: #{@tab_bar_gutter}px" if @tab_bar_gutter
-        styles.join("; ") if styles.any?
-      end
-
-      def has_extra_content?
-        @tab_bar_extra_content_left.present? ||
-          @tab_bar_extra_content_right.present?
-      end
-
-      def extra_content_left
-        @tab_bar_extra_content_left
-      end
-
-      def extra_content_right
-        @tab_bar_extra_content_right
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:type, TYPES)
-        validate_inclusion!(:size, SIZES)
-        validate_inclusion!(:tab_position, TAB_POSITIONS)
-        if @indicator[:align]
-          unless INDICATOR_ALIGNS.include?(@indicator[:align])
-            raise ArgumentError, "Invalid indicator align: #{@indicator[:align]}. Must be one of: #{INDICATOR_ALIGNS.join(', ')}"
-          end
-        end
-      end
-    end
-  end
-end