hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi/date_picker/shared_rendering.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module DatePicker
-    module SharedRendering
-      SIZES = [ :small, :middle, :large ].freeze
-      PICKERS = [ :date, :week, :month, :quarter, :year ].freeze
-
-      # Default Day.js display formats
-      DEFAULT_DATE_FORMAT = "YYYY-MM-DD"
-      DEFAULT_DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss"
-      DEFAULT_DATETIME_NO_SECONDS_FORMAT = "YYYY-MM-DD HH:mm"
-
-      # ISO value for hidden input (always standard format for Rails)
-      def iso_value(value)
-        return nil if value.blank?
-
-        datetime_value = parse_datetime(value)
-        return nil if datetime_value.nil?
-
-        if @show_time
-          show_seconds? ? datetime_value.strftime("%Y-%m-%d %H:%M:%S") : datetime_value.strftime("%Y-%m-%d %H:%M")
-        else
-          datetime_value.strftime("%Y-%m-%d")
-        end
-      end
-
-      # Formatted value for visible input (uses display_format or default)
-      def formatted_value(value)
-        return nil if value.blank?
-
-        datetime_value = parse_datetime(value)
-        return value.to_s if datetime_value.nil?
-
-        return format_quarter(datetime_value) if @picker == :quarter && !@display_format.present? && !@format.present?
-
-        # Priority: display_format (Day.js) > format (strftime legacy) > default
-        if @display_format.present?
-          datetime_value.strftime(dayjs_to_strftime(@display_format))
-        elsif @format.present?
-          datetime_value.strftime(@format)
-        else
-          datetime_value.strftime(default_strftime_format)
-        end
-      end
-
-      # Day.js format string for JS controller
-      def js_display_format
-        return @display_format if @display_format.present?
-
-        if @show_time
-          show_seconds? ? DEFAULT_DATETIME_FORMAT : DEFAULT_DATETIME_NO_SECONDS_FORMAT
-        else
-          DEFAULT_DATE_FORMAT
-        end
-      end
-
-      # Ruby strftime format (for legacy @format support)
-      def display_format
-        return @format if @format.present?
-        default_strftime_format
-      end
-
-      def default_strftime_format
-        if @show_time
-          show_seconds? ? "%Y-%m-%d %H:%M:%S" : "%Y-%m-%d %H:%M"
-        else
-          case @picker
-          when :month
-            "%Y-%m"
-          when :year
-            "%Y"
-          when :week
-            "%G-W%V"
-          else
-            "%Y-%m-%d"
-          end
-        end
-      end
-
-      # Convert Day.js format to Ruby strftime format
-      def dayjs_to_strftime(dayjs_format)
-        dayjs_format
-          .gsub("YYYY", "%Y")
-          .gsub("YY", "%y")
-          .gsub("MMMM", "%B")  # Full month name
-          .gsub("MMM", "%b")   # Abbreviated month name
-          .gsub("MM", "%m")    # Month with zero-padding
-          .gsub("M", "%-m")    # Month without padding
-          .gsub("DD", "%d")    # Day with zero-padding
-          .gsub("D", "%-d")    # Day without padding
-          .gsub("HH", "%H")
-          .gsub("hh", "%I")
-          .gsub("mm", "%M")
-          .gsub("ss", "%S")
-          .gsub("A", "%p")
-          .gsub("a", "%P")
-      end
-
-      def parse_datetime(value)
-        return nil if value.nil?
-        return value if value.is_a?(Time) || value.is_a?(DateTime)
-        return @show_time ? value.to_time : value if value.is_a?(Date)
-
-        str = value.to_s
-        if @show_time && str.include?(" ")
-          # Parse datetime string like "2026-03-15 14:30:00"
-          Time.parse(str)
-        else
-          Date.parse(str)
-        end
-      rescue ArgumentError, TypeError
-        nil
-      end
-
-      def parse_date(value)
-        parse_datetime(value)&.to_date
-      end
-
-      def show_seconds?
-        # Use explicit @show_seconds if defined, otherwise derive from @show_time
-        return @show_seconds if instance_variable_defined?(:@show_seconds) && !@show_seconds.nil?
-        @show_time
-      end
-
-      def use_12_hours?
-        return false unless @display_format.present?
-        # Check if format has 'hh' (12-hour) and 'A' or 'a' (AM/PM)
-        @display_format.include?("hh") && (@display_format.include?("A") || @display_format.include?("a"))
-      end
-
-      def format_quarter(date_value)
-        quarter = ((date_value.month - 1) / 3) + 1
-        "Q#{quarter} #{date_value.year}"
-      end
-
-      def picker_mode
-        case @picker
-        when :date, :week
-          :month  # Date and week both show month view
-        when :month
-          :year   # Month picker shows year view (12 months)
-        when :quarter
-          :quarter  # Quarter picker shows quarter view (Q1-Q4)
-        when :year
-          :decade  # Year picker shows decade view (years)
-        else
-          :month
-        end
-      end
-
-      def base_wrapper_classes(base:, extra_classes: [])
-        class_names(
-          base,
-          {
-            lg: @size == :large,
-            sm: @size == :small,
-            borderless: !@bordered,
-            disabled: @disabled,
-            "allow-clear": @allow_clear,
-            "has-value": value_present?(@value)
-          },
-          extra_classes
-        )
-      end
-
-      def picker_panel_attributes(range: nil)
-        data_attrs = {
-          action: "hakumi--calendar:select->hakumi--date-picker#handleCalendarSelect"
-        }
-        data_attrs[:date_range] = range if range
-        data_attrs
-      end
-
-      def calendar_component_options(value:, range: nil)
-        {
-          value: value,
-          default_value: @default_value,
-          fullscreen: false,
-          mode: picker_mode,
-          show_week: @picker == :week,  # Show week column for week picker
-          static: true,
-          disabled_date: @disabled_date,
-          data: picker_panel_attributes(range: range)
-        }
-      end
-
-      def placeholder_text
-        @placeholder || "Select date"
-      end
-
-      def range_placeholders
-        return @placeholder if @placeholder.is_a?(Array)
-
-        [ "Start date", "End date" ]
-      end
-    end
-  end
-end

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

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Descriptions
-    # Hakumi Descriptions component
-    # Displays multiple read-only fields in a group.
-    class Component < Hakumi::BaseComponent
-      SIZE_OPTIONS = [ :default, :middle, :small ].freeze
-      LAYOUT_OPTIONS = [ :horizontal, :vertical ].freeze
-
-      COLUMN_BREAKPOINTS = [ :xs, :sm, :md, :lg, :xl, :xxl ].freeze
-
-      renders_many :items, ->(
-        label:,
-        content: nil,
-        span: 1,
-        label_style: nil,
-        content_style: nil,
-        **options,
-        &block
-      ) do
-        item = Hakumi::Descriptions::Item::Component.new(
-          label: label,
-          content: content,
-          span: span,
-          label_style: label_style,
-          content_style: content_style,
-          **options
-        )
-        item.content = capture(&block) if block
-        item
-      end
-
-      def initialize(
-        title: nil,
-        extra: nil,
-        bordered: false,
-        size: :default,
-        layout: :horizontal,
-        column: 3,
-        colon: true,
-        **html_options
-      )
-        @title = title
-        @extra = extra
-        @bordered = bordered
-        @size = size
-        @layout = layout
-        @column = column
-        @colon = colon
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZE_OPTIONS)
-        validate_inclusion!(:layout, LAYOUT_OPTIONS)
-      end
-
-      def max_column_count
-        case @column
-        when Integer
-          @column.positive? ? @column : 3
-        when Hash
-          values = @column.values.compact
-          values.empty? ? 3 : values.max
-        else
-          3
-        end
-      end
-
-      def rows
-        cols = max_column_count
-        result = []
-        current_row = []
-        current_span = 0
-
-        items.each do |item|
-          span = item.span.to_i
-          span = 1 if span <= 0
-          span = cols if span > cols
-
-          if current_span + span > cols && !current_row.empty?
-            result << current_row
-            current_row = []
-            current_span = 0
-          end
-
-          current_row << [ item, span ]
-          current_span += span
-        end
-
-        result << current_row unless current_row.empty?
-
-        # Fill remaining space in the last row by extending the last item's span
-        result.map do |row|
-          total_span = row.sum { |(_, span)| span }
-          if total_span < cols && !row.empty?
-            remaining = cols - total_span
-            last_item, last_span = row.last
-            row[0...-1] + [ [ last_item, last_span + remaining ] ]
-          else
-            row
-          end
-        end
-      end
-
-      def wrapper_classes
-        column_classes = build_column_classes
-
-        class_names(
-          "descriptions",
-          {
-            bordered: @bordered,
-            "small": @size == :small,
-            "middle": @size == :middle,
-            "vertical": @layout == :vertical
-          },
-          column_classes
-        )
-      end
-
-      def build_column_classes
-        base = []
-
-        case @column
-        when Integer
-          base << "hakumi-descriptions-column-#{@column}"
-        when Hash
-          default_col = @column[:column] || @column[:default]
-          base << "hakumi-descriptions-column-#{default_col}" if default_col
-
-          COLUMN_BREAKPOINTS.each do |bp|
-            value = @column[bp]
-            next unless value
-
-            base << "hakumi-descriptions-column-#{bp}-#{value}"
-          end
-        end
-
-        base
-      end
-
-      def wrapper_attributes
-        merge_attributes({ class: wrapper_classes }, @html_options)
-      end
-
-      def table_classes
-        "hakumi-descriptions-view"
-      end
-
-      def label_cell_classes
-        classes = [ "hakumi-descriptions-item-label" ]
-        classes << "hakumi-descriptions-item-label-colon" if @colon && @layout == :horizontal
-        classes.join(" ")
-      end
-
-      def content_cell_classes
-        "hakumi-descriptions-item-content"
-      end
-
-      def render_title
-        return nil unless @title
-
-        content_tag(:div, class: "hakumi-descriptions-title") do
-          @title
-        end
-      end
-
-      def render_extra
-        return nil unless @extra
-
-        content_tag(:div, class: "hakumi-descriptions-extra") do
-          @extra
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/descriptions/item/component.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Descriptions
-    module Item
-      class Component < Hakumi::BaseComponent
-        attr_accessor :content
-        attr_reader :label, :span, :label_style, :content_style
-
-        def initialize(
-          label:,
-          content: nil,
-          span: 1,
-          label_style: nil,
-          content_style: nil,
-          **html_options
-        )
-          @label = label
-          @content = content
-          @span = span
-          @label_style = label_style
-          @content_style = content_style
-          @html_options = html_options
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Divider
-    class Component < Hakumi::BaseComponent
-      ORIENTATIONS = [ :horizontal, :vertical ].freeze
-      PLACEMENTS = [ :left, :center, :right ].freeze
-
-      def initialize(
-        orientation: :horizontal,
-        dashed: false,
-        plain: false,
-        orientation_margin: nil,
-        **html_options
-      )
-        @orientation = orientation
-        @dashed = dashed
-        @plain = plain
-        @orientation_margin = orientation_margin
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def call
-        if @orientation == :vertical
-          content_tag(:span, nil, wrapper_attributes)
-        else
-          content_tag(:div, content_wrapper, wrapper_attributes)
-        end
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:orientation, ORIENTATIONS)
-        validate_inclusion!(:orientation_margin, PLACEMENTS) if @orientation_margin
-      end
-
-      def wrapper_classes
-        classes = [ "hakumi-divider", "hakumi-divider-#{@orientation}" ]
-        classes << "hakumi-divider-dashed" if @dashed
-        classes << "hakumi-divider-with-text" if content.present?
-        classes << "hakumi-divider-plain" if @plain && content.present?
-        classes << "hakumi-divider-with-text-#{@orientation_margin}" if content.present? && @orientation_margin
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
-      end
-
-      def wrapper_attributes
-        attrs = {
-          class: wrapper_classes,
-          role: "separator"
-        }
-
-        merge_attributes(attrs, @html_options.except(:class))
-      end
-
-      def content_wrapper
-        return nil if content.blank?
-
-        tag.span(content, class: "hakumi-divider-inner-text")
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Drawer
-    class Component < Hakumi::BaseComponent
-      PLACEMENTS = %i[left right top bottom].freeze
-      SIZES = {
-        default: 378,
-        large: 736
-      }.freeze
-
-      # Slots for content
-      renders_one :header
-      renders_one :body
-      renders_one :footer
-      renders_one :extra
-
-      def initialize(
-        open: false,
-        placement: :right,
-        size: :default,
-        width: nil,
-        height: nil,
-        closable: true,
-        mask: true,
-        mask_closable: true,
-        keyboard: true,
-        destroy_on_close: false,
-        **html_attributes
-      )
-        @open = open
-        @placement = placement
-        @size = size
-        @width = width
-        @height = height
-        @closable = closable
-        @mask = mask
-        @mask_closable = mask_closable
-        @keyboard = keyboard
-        @destroy_on_close = destroy_on_close
-        @html_attributes = html_attributes
-
-        validate_props!
-      end
-
-      def drawer_classes
-        classes = [ "hakumi-drawer", "hakumi-drawer-#{@placement}" ]
-        classes << "hakumi-drawer-open" if @open
-        classes.join(" ")
-      end
-
-      def root_attributes
-        base_attrs = {
-          class: drawer_classes,
-          data: data_attributes
-        }
-
-        merge_attributes(base_attrs, @html_attributes)
-      end
-
-      def data_attributes
-        {
-          controller: "hakumi--drawer",
-          hakumi__drawer_open_value: @open,
-          hakumi__drawer_placement_value: @placement.to_s,
-          hakumi__drawer_mask_closable_value: @mask_closable,
-          hakumi__drawer_keyboard_value: @keyboard,
-          hakumi__drawer_destroy_on_close_value: @destroy_on_close
-        }.merge(@html_attributes[:data] || {})
-      end
-
-      def wrapper_style
-        size_value = resolve_size
-        if %i[left right].include?(@placement)
-          "width: #{dimension_to_css(@width || size_value)};"
-        else
-          "height: #{dimension_to_css(@height || size_value)};"
-        end
-      end
-
-      def render_header?
-        header? || @closable || extra?
-      end
-
-      def render_footer?
-        footer?
-      end
-
-      # Content resolution: body slot > block content
-      def body_content
-        body? ? body : content
-      end
-
-      private
-
-      def resolve_size
-        return @size if @size.is_a?(Numeric) || @size.is_a?(String)
-
-        SIZES.fetch(@size, SIZES[:default])
-      end
-
-      def validate_props!
-        validate_inclusion!(:placement, PLACEMENTS)
-        validate_inclusion!(:size, SIZES.keys) if @size.is_a?(Symbol)
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Dropdown
-    class Component < Hakumi::BaseComponent
-      TRIGGERS = %i[hover click context_menu].freeze
-      PLACEMENTS = %i[bottom bottom_left bottom_right top top_left top_right].freeze
-
-      renders_one :trigger
-      renders_many :items, types: {
-        item: {
-          renders: ->(key:, label: nil, href: nil, target: nil, icon: nil, disabled: false, danger: false, **options, &block) do
-            Hakumi::Dropdown::Item::Component.new(
-              key: key,
-              label: label,
-              href: href,
-              target: target,
-              icon: icon,
-              disabled: disabled,
-              danger: danger,
-              **options,
-              &block
-            )
-          end,
-          as: :item
-        },
-        divider: {
-          renders: -> { Hakumi::Dropdown::Divider::Component.new },
-          as: :divider
-        }
-      }
-
-      def initialize(
-        trigger: :hover,
-        placement: :bottom_left,
-        disabled: false,
-        **html_options
-      )
-        @trigger = trigger
-        @placement = placement
-        @disabled = disabled
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      attr_reader :trigger_type, :placement, :disabled
-
-      def dropdown_classes
-        classes = [ "hakumi-dropdown-trigger" ]
-        classes << "hakumi-dropdown-disabled" if @disabled
-        classes.join(" ")
-      end
-
-      def menu_classes
-        "hakumi-dropdown-menu"
-      end
-
-      def stimulus_controller
-        "hakumi--dropdown"
-      end
-
-      def stimulus_values
-        {
-          trigger: @trigger.to_s,
-          placement: @placement.to_s.dasherize,
-          disabled: @disabled
-        }
-      end
-
-      def placement_class
-        "hakumi-dropdown-placement-#{@placement.to_s.dasherize}"
-      end
-
-      def wrapper_attributes
-        base_data = {
-          controller: stimulus_controller,
-          "#{stimulus_controller}-trigger-value" => @trigger.to_s,
-          "#{stimulus_controller}-placement-value" => @placement.to_s.dasherize,
-          "#{stimulus_controller}-disabled-value" => @disabled.to_s
-        }
-
-        merge_attributes(
-          { class: dropdown_classes, data: base_data },
-          @html_options
-        )
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:trigger, TRIGGERS)
-        validate_inclusion!(:placement, PLACEMENTS)
-      end
-    end
-  end
-end