hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/calendar/day_cell.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Calendar
+    class DayCell
+      extend T::Sig
+
+      sig do
+        params(
+          date: Date,
+          day: Integer,
+          in_month: T::Boolean,
+          today: T::Boolean,
+          selected: T::Boolean,
+          disabled: T::Boolean,
+          weekend: T::Boolean
+        ).void
+      end
+      def initialize(date:, day:, in_month:, today:, selected:, disabled:, weekend:)
+        @date = T.let(date, Date)
+        @day = T.let(day, Integer)
+        @in_month = T.let(in_month, T::Boolean)
+        @today = T.let(today, T::Boolean)
+        @selected = T.let(selected, T::Boolean)
+        @disabled = T.let(disabled, T::Boolean)
+        @weekend = T.let(weekend, T::Boolean)
+      end
+
+      sig { returns(Date) }
+      attr_reader :date
+
+      sig { returns(Integer) }
+      attr_reader :day
+
+      sig { returns(T::Boolean) }
+      def in_month?
+        @in_month
+      end
+
+      sig { returns(T::Boolean) }
+      def today?
+        @today
+      end
+
+      sig { returns(T::Boolean) }
+      def selected?
+        @selected
+      end
+
+      sig { returns(T::Boolean) }
+      def disabled?
+        @disabled
+      end
+
+      sig { returns(T::Boolean) }
+      def weekend?
+        @weekend
+      end
+    end
+  end
+end

data/app/components/hakumi_components/calendar/display_model.rb

@@ -0,0 +1,237 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Calendar
+    class DisplayModel
+      extend T::Sig
+
+      DateRange = T.type_alias { T.nilable([ T.nilable(Date), T.nilable(Date) ]) }
+      YearRangeValue = T.type_alias { T.any(T::Range[Integer], T::Array[Integer]) }
+      YearRangeInput = T.type_alias { T.nilable(YearRangeValue) }
+      DisabledDatePredicate = T.type_alias { T.nilable(T.proc.params(date: Date).returns(T::Boolean)) }
+
+      sig do
+        params(
+          current_date: Date,
+          selected_value: T.nilable(Date),
+          show_week: T::Boolean,
+          year_range: YearRangeInput,
+          valid_range: DateRange,
+          disabled_date: DisabledDatePredicate,
+          locale_data: HakumiComponents::Calendar::LocalePack
+        ).void
+      end
+      def initialize(current_date:, selected_value:, show_week:, year_range:, valid_range:, disabled_date:, locale_data:)
+        @current_date = T.let(current_date, Date)
+        @selected_value = T.let(selected_value, T.nilable(Date))
+        @show_week = T.let(show_week, T::Boolean)
+        @year_range = T.let(year_range, YearRangeInput)
+        @valid_range = T.let(valid_range, DateRange)
+        @disabled_date = T.let(disabled_date, DisabledDatePredicate)
+        @locale_data = T.let(locale_data, HakumiComponents::Calendar::LocalePack)
+        @weeks_in_month = T.let(nil, T.nilable(T::Array[HakumiComponents::Calendar::WeekRow]))
+      end
+
+      sig { returns(T::Array[String]) }
+      def weekday_names
+        @locale_data.days_short
+      end
+
+      sig { returns(T::Array[String]) }
+      def month_names
+        @locale_data.months_full
+      end
+
+      sig { returns(T::Array[String]) }
+      def month_names_short
+        @locale_data.months_short
+      end
+
+      sig { returns(T::Array[HakumiComponents::Calendar::WeekRow]) }
+      def weeks_in_month
+        @weeks_in_month ||= build_weeks_for_month(current_year, current_month)
+      end
+
+      sig { returns(T::Array[HakumiComponents::Calendar::PanelEntry]) }
+      def months_in_year
+        today = Date.today
+        selected = @selected_value
+
+        (1..12).map do |month|
+          HakumiComponents::Calendar::PanelEntry.new(
+            value: month,
+            label: month_names_short.fetch(month - 1),
+            current: month == current_month && current_year == today.year,
+            selected: !selected.nil? && month == selected.month && current_year == selected.year
+          )
+        end
+      end
+
+      sig { returns(T::Array[HakumiComponents::Calendar::PanelEntry]) }
+      def quarters_in_year
+        today = Date.today
+        selected = @selected_value
+        current_quarter = ((current_month - 1) / 3) + 1
+        selected_quarter = selected.nil? ? nil : ((selected.month - 1) / 3) + 1
+        selected_year = selected&.year
+
+        (1..4).map do |quarter|
+          HakumiComponents::Calendar::PanelEntry.new(
+            value: quarter,
+            label: "Q#{quarter}",
+            current: quarter == current_quarter && current_year == today.year,
+            selected: !selected_quarter.nil? && quarter == selected_quarter && current_year == selected_year
+          )
+        end
+      end
+
+      sig { returns(T::Array[HakumiComponents::Calendar::PanelEntry]) }
+      def years_in_decade
+        decade_start = (current_year / 10) * 10
+        start_year = decade_start - 1
+        end_year = decade_start + 10
+        today = Date.today
+        selected = @selected_value
+
+        (start_year..end_year).map do |year|
+          HakumiComponents::Calendar::PanelEntry.new(
+            value: year,
+            label: year.to_s,
+            current: year == today.year,
+            selected: !selected.nil? && year == selected.year,
+            enabled: year >= decade_start && year < decade_start + 10
+          )
+        end
+      end
+
+      sig { returns(String) }
+      def decade_range_label
+        decade_start = (current_year / 10) * 10
+        "#{decade_start}-#{decade_start + 9}"
+      end
+
+      sig { returns(T::Array[Integer]) }
+      def years_range
+        return @year_range.to_a if @year_range.is_a?(Range)
+        return @year_range if @year_range.is_a?(Array)
+
+        ((current_year - 10)..(current_year + 10)).to_a
+      end
+
+      sig { params(date: Date).returns(T::Boolean) }
+      def date_disabled?(date)
+        disabled_date = @disabled_date
+        return false unless disabled_date
+
+        disabled_date.call(date)
+      end
+
+      sig { params(date: Date).returns(T::Boolean) }
+      def date_in_valid_range?(date)
+        valid_range = @valid_range
+        return true unless valid_range
+
+        start_date, end_date = valid_range
+        (start_date.nil? || date >= start_date) && (end_date.nil? || date <= end_date)
+      end
+
+      sig { params(cell: HakumiComponents::Calendar::DayCell).returns(String) }
+      def cell_classes(cell)
+        classes = [ "hakumi-calendar-cell" ]
+        classes << "hakumi-calendar-cell-in-view" if cell.in_month?
+        classes << "hakumi-calendar-cell-today" if cell.today?
+        classes << "hakumi-calendar-cell-selected" if cell.selected?
+        classes << "hakumi-calendar-cell-disabled" if cell.disabled?
+        classes << "hakumi-calendar-cell-weekend" if cell.weekend?
+        classes.join(" ")
+      end
+
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry).returns(String) }
+      def month_cell_classes(entry)
+        panel_cell_classes(entry, "month")
+      end
+
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry).returns(String) }
+      def quarter_cell_classes(entry)
+        panel_cell_classes(entry, "quarter")
+      end
+
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry).returns(String) }
+      def year_cell_classes(entry)
+        panel_cell_classes(entry, "year")
+      end
+
+      sig { params(date: Date).returns(Integer) }
+      def week_number(date)
+        date.cweek
+      end
+
+      private
+
+      sig { returns(Integer) }
+      def current_year
+        @current_date.year
+      end
+
+      sig { returns(Integer) }
+      def current_month
+        @current_date.month
+      end
+
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry, kind: String).returns(String) }
+      def panel_cell_classes(entry, kind)
+        classes = [ "hakumi-calendar-cell", "hakumi-calendar-cell-#{kind}" ]
+        classes << "hakumi-calendar-cell-selected" if entry.selected?
+        classes << "hakumi-calendar-cell-current" if entry.current?
+        classes << "hakumi-calendar-cell-disabled" unless entry.enabled?
+        classes.join(" ")
+      end
+
+      sig { params(year: Integer, month: Integer).returns(T::Array[HakumiComponents::Calendar::WeekRow]) }
+      def build_weeks_for_month(year, month)
+        first_day = Date.new(year, month, 1)
+        last_day = Date.new(year, month, -1)
+
+        start_date = first_day - first_day.wday
+        end_date = last_day + (6 - last_day.wday)
+
+        selected = @selected_value
+        selected_week_number = selected&.cweek
+        selected_week_year = selected&.cwyear
+
+        weeks = T.let([], T::Array[HakumiComponents::Calendar::WeekRow])
+        current = start_date
+
+        while current <= end_date
+          monday = current.wday == 0 ? current + 1 : current - current.wday + 1
+          week_number = monday.cweek
+          week_year = monday.cwyear
+
+          days = T.let([], T::Array[HakumiComponents::Calendar::DayCell])
+          (0..6).each do |day_offset|
+            date = current + day_offset
+            days << HakumiComponents::Calendar::DayCell.new(
+              date: date,
+              day: date.day,
+              in_month: date.month == month,
+              today: date == Date.today,
+              selected: !selected.nil? && date == selected,
+              disabled: date_disabled?(date) || !date_in_valid_range?(date),
+              weekend: date.saturday? || date.sunday?
+            )
+          end
+
+          weeks << HakumiComponents::Calendar::WeekRow.new(
+            week_number: week_number,
+            week_selected: @show_week && selected_week_number == week_number && selected_week_year == week_year,
+            days: days
+          )
+          current += 7
+        end
+
+        weeks
+      end
+    end
+  end
+end

data/app/components/hakumi_components/calendar/event_entry.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Calendar
+    class EventEntry
+      extend T::Sig
+
+      InputValue = T.type_alias { T.nilable(T.any(String, Symbol, Integer)) }
+      InputAttributes = T.type_alias { T::Hash[Symbol, InputValue] }
+
+      sig { params(id: T.nilable(String), type: Symbol, content: T.nilable(String)).void }
+      def initialize(id: nil, type: :default, content: nil)
+        @id = T.let(id, T.nilable(String))
+        @type = T.let(type, Symbol)
+        @content = T.let(content, T.nilable(String))
+      end
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id, :content
+
+      sig { returns(Symbol) }
+      attr_reader :type
+
+      sig { params(events: T::Array[InputAttributes]).returns(T::Array[HakumiComponents::Calendar::EventEntry]) }
+      def self.coerce_all(events)
+        events.map { |event| coerce(event) }
+      end
+
+      sig { params(event: InputAttributes).returns(HakumiComponents::Calendar::EventEntry) }
+      def self.coerce(event)
+        new(
+          id: event[:id]&.to_s,
+          type: coerce_type(event[:type]),
+          content: event[:content]&.to_s
+        )
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: InputValue).returns(Symbol) }
+        def coerce_type(value)
+          return value if value.is_a?(Symbol)
+          return value.to_sym if value.is_a?(String) && !value.empty?
+
+          :default
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/calendar/locale_pack.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Calendar
+    class LocalePack
+      extend T::Sig
+
+      sig do
+        params(
+          days_short: T::Array[String],
+          days_full: T::Array[String],
+          months_short: T::Array[String],
+          months_full: T::Array[String]
+        ).void
+      end
+      def initialize(days_short:, days_full:, months_short:, months_full:)
+        @days_short = T.let(days_short, T::Array[String])
+        @days_full = T.let(days_full, T::Array[String])
+        @months_short = T.let(months_short, T::Array[String])
+        @months_full = T.let(months_full, T::Array[String])
+      end
+
+      sig { returns(T::Array[String]) }
+      attr_reader :days_short, :days_full, :months_short, :months_full
+    end
+  end
+end

data/app/components/hakumi_components/calendar/panel_entry.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Calendar
+    class PanelEntry
+      extend T::Sig
+
+      sig do
+        params(
+          value: Integer,
+          label: String,
+          current: T::Boolean,
+          selected: T::Boolean,
+          enabled: T::Boolean
+        ).void
+      end
+      def initialize(value:, label:, current:, selected:, enabled: true)
+        @value = T.let(value, Integer)
+        @label = T.let(label, String)
+        @current = T.let(current, T::Boolean)
+        @selected = T.let(selected, T::Boolean)
+        @enabled = T.let(enabled, T::Boolean)
+      end
+
+      sig { returns(Integer) }
+      attr_reader :value
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { returns(T::Boolean) }
+      def current?
+        @current
+      end
+
+      sig { returns(T::Boolean) }
+      def selected?
+        @selected
+      end
+
+      sig { returns(T::Boolean) }
+      def enabled?
+        @enabled
+      end
+    end
+  end
+end

data/app/components/hakumi_components/calendar/week_row.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Calendar
+    class WeekRow
+      extend T::Sig
+
+      sig { params(week_number: Integer, week_selected: T::Boolean, days: T::Array[HakumiComponents::Calendar::DayCell]).void }
+      def initialize(week_number:, week_selected:, days:)
+        @week_number = T.let(week_number, Integer)
+        @week_selected = T.let(week_selected, T::Boolean)
+        @days = T.let(days, T::Array[HakumiComponents::Calendar::DayCell])
+      end
+
+      sig { returns(Integer) }
+      attr_reader :week_number
+
+      sig { returns(T::Array[HakumiComponents::Calendar::DayCell]) }
+      attr_reader :days
+
+      sig { returns(T::Boolean) }
+      def week_selected?
+        @week_selected
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@
   <% end %>
 
   <div class="hakumi-card-body">
-    <% if @loading %>
+    <% if loading? %>
       <div class="hakumi-card-loading-content">
         <div class="hakumi-row" style="margin-bottom: 16px;">
           <div class="hakumi-col hakumi-col-22" style="display: block; flex: 0 0 91.66666667%; max-width: 91.66666667%;">
@@ -48,7 +48,7 @@
   <% if actions.any? %>
     <ul class="hakumi-card-actions">
       <% actions.each do |action| %>
-        <li style="width: <%= 100.0 / actions.length %>%">
+        <li style="width: <%= action_width %>">
           <span><%= action %></span>
         </li>
       <% end %>

data/app/components/hakumi_components/card/component.rb

@@ -1,73 +1,104 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Card
-    # Hakumi Card component
-    # A container for displaying content in a box.
-    #
-    # @example Basic usage with slots
-    #   <%= render HakumiComponents::Card::Component.new do |card| %>
-    #     <% card.with_header { "Card Title" } %>
-    #     <% card.with_extra { "More" } %>
-    #     Card content
-    #   <% end %>
-    #
-    # @example With cover and actions
-    #   <%= render HakumiComponents::Card::Component.new do |card| %>
-    #     <% card.with_cover { image_tag("example.png") } %>
-    #     <% card.with_header { "Card Title" } %>
-    #     Card content
-    #     <% card.with_action { link_to "Edit", edit_path } %>
-    #     <% card.with_action { link_to "Delete", "#" } %>
-    #   <% end %>
     class Component < HakumiComponents::BaseComponent
-      # Slots for content
+      extend T::Sig
+
+      SIZES = T.let(%i[default small].freeze, T::Array[Symbol])
+      TYPES = T.let([ :inner ].freeze, T::Array[Symbol])
+
       renders_one :header
       renders_one :cover
       renders_one :body
       renders_one :extra
       renders_many :actions
 
+      sig do
+        params(
+          bordered: T::Boolean,
+          hoverable: T::Boolean,
+          loading: T::Boolean,
+          size: Symbol,
+          type: T.nilable(Symbol),
+          href: T.nilable(String),
+          target: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         bordered: true,
         hoverable: false,
         loading: false,
-        size: :default, # :default, :small
-        type: nil, # :inner, nil
+        size: :default,
+        type: nil,
         href: nil,
         target: nil,
         **html_options
       )
-        @bordered = bordered
-        @hoverable = hoverable
-        @loading = loading
-        @size = size
-        @type = type
-        @href = href
-        @target = target
-        @html_options = html_options
-      end
+        @bordered = T.let(cast_boolean(bordered) != false, T::Boolean)
+        @hoverable = T.let(cast_boolean(hoverable) ? true : false, T::Boolean)
+        @loading = T.let(cast_boolean(loading) ? true : false, T::Boolean)
+        @size = T.let(size.to_sym, Symbol)
+        @type = T.let(type&.to_sym, T.nilable(Symbol))
+        @href = T.let(href, T.nilable(String))
+        @target = T.let(target, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
-      private
-
-      def wrapper_tag
-        @href.present? ? :a : :div
+        validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        attrs = @html_options.dup
-        attrs[:class] = classes
-
-        if @href.present?
+        attrs = T.let({ class: classes }, Types::HtmlAttributes)
+        if link_card?
           attrs[:href] = @href
           attrs[:target] = @target if @target
         end
 
-        attrs
+        merge_attributes(attrs, @html_options.except(:class))
+      end
+
+      sig { returns(Symbol) }
+      def wrapper_tag
+        link_card? ? :a : :div
+      end
+
+      sig { returns(T::Boolean) }
+      def render_header?
+        header? || extra?
+      end
+
+      sig { returns(T::Boolean) }
+      def loading?
+        @loading
       end
 
+      sig { returns(Types::Renderable) }
+      def body_content
+        body? ? body : content
+      end
+
+      sig { returns(String) }
+      def action_width
+        count = actions.length
+        return "100%" if count.zero?
+
+        "#{100.0 / count}%"
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:type, TYPES) unless @type.nil?
+      end
+
+      sig { returns(String) }
       def classes
-        class_names(
+        component_classes(
           "card",
           {
             bordered: @bordered,
@@ -75,19 +106,15 @@ module HakumiComponents
             small: @size == :small,
             "type-inner": @type == :inner,
             loading: @loading,
-            link: @href.present?
+            link: link_card?
           },
-          @html_options[:class]
+          @html_options
         )
       end
 
-      def render_header?
-        header? || extra?
-      end
-
-      # Content resolution: body slot > block content
-      def body_content
-        body? ? body : content
+      sig { returns(T::Boolean) }
+      def link_card?
+        !@href.nil? && @href.present?
       end
     end
   end

data/app/components/hakumi_components/card/grid/component.html.erb

@@ -1,3 +1,3 @@
-<div class="<%= classes %>" <%= tag.attributes(@html_options.except(:class)) %>>
+<div <%= tag.attributes(wrapper_attributes) %>>
   <%= content %>
 </div>