hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,41 +1,90 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Calendar
     class Component < HakumiComponents::BaseComponent
-      MODES = %i[month year quarter decade].freeze
-      WEEK_DAYS = %i[sunday monday tuesday wednesday thursday friday saturday].freeze
-      LOCALES = {
-        en: {
+      extend T::Sig
+
+      DateInput = T.type_alias { BaseComponent::DateInput }
+      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) }
+      DateCellRenderer = T.type_alias { T.nilable(T.proc.params(date: Date).returns(Types::RenderedContent)) }
+      MonthCellRenderer = T.type_alias { T.nilable(T.proc.params(month: Integer).returns(Types::RenderedContent)) }
+      HeaderRendererProc = T.type_alias do
+        T.nilable(T.proc.params(
+          arg0: Date,
+          arg1: Symbol,
+          arg2: NilClass,
+          arg3: NilClass
+        ).returns(Types::RenderedContent))
+      end
+      HeaderRenderer = T.type_alias { T.nilable(T.any(FalseClass, HeaderRendererProc)) }
+      DisabledDatePredicate = T.type_alias { T.nilable(T.proc.params(date: Date).returns(T::Boolean)) }
+      ControllerLocalValue = T.type_alias { T.nilable(T.any(Types::HtmlPrimitive, Types::StringOrSymbolArray)) }
+      EventInputKey = T.type_alias { T.any(Date, Types::HtmlKey) }
+      EventInputMap = T.type_alias { T::Hash[EventInputKey, T::Array[HakumiComponents::Calendar::EventEntry::InputAttributes]] }
+      EventsByDate = T.type_alias { T::Hash[Date, T::Array[HakumiComponents::Calendar::EventEntry]] }
+
+      MODES = T.let(%i[month year quarter decade].freeze, T::Array[Symbol])
+      LOCALES = T.let({
+        en: HakumiComponents::Calendar::LocalePack.new(
           days_short: %w[Su Mo Tu We Th Fr Sa],
           days_full: %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday],
           months_short: %w[Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec],
           months_full: %w[January February March April May June July August September October November December]
-        },
-        es: {
-          days_short: %w[Do Lu Ma Mi Ju Vi Sá],
-          days_full: %w[Domingo Lunes Martes Miércoles Jueves Viernes Sábado],
+        ),
+        es: HakumiComponents::Calendar::LocalePack.new(
+          days_short: [ "Do", "Lu", "Ma", "Mi", "Ju", "Vi", "Sá" ],
+          days_full: [ "Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado" ],
           months_short: %w[Ene Feb Mar Abr May Jun Jul Ago Sep Oct Nov Dic],
-          months_full: %w[Enero Febrero Marzo Abril Mayo Junio Julio Agosto Septiembre Octubre Noviembre Diciembre]
-        }
-      }.freeze
+          months_full: [ "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre" ]
+        )
+      }.freeze, T::Hash[Symbol, HakumiComponents::Calendar::LocalePack])
 
       renders_one :header_content
 
+      sig do
+        params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ControllerLocalValue])
+      end
       def self.extract_controller_locals(params)
+        value = html_param(params, :value)
+        default_value = html_param(params, :default_value)
+        mode = symbol_html_param(html_param(params, :mode))
+        locale = symbol_html_param(html_param(params, :locale))
+        valid_range_input = html_param(params, :valid_range)
+
         {
-          value: params[:value],
-          default_value: params[:default_value],
-          mode: params[:mode],
-          fullscreen: params[:fullscreen],
-          show_week: params[:show_week],
-          locale: params[:locale],
-          valid_range: params[:valid_range]
+          value: value&.to_s,
+          default_value: default_value&.to_s,
+          mode: mode,
+          fullscreen: boolean_html_param(html_param(params, :fullscreen)),
+          show_week: boolean_html_param(html_param(params, :show_week)),
+          locale: locale,
+          valid_range: valid_range_input.is_a?(Array) ? valid_range_input : nil
         }
       end
 
-      EVENT_TYPES = %i[success warning error default].freeze
-
+      sig do
+        params(
+          value: DateInput,
+          default_value: DateInput,
+          mode: BaseComponent::SymbolInput,
+          fullscreen: T.nilable(T::Boolean),
+          show_week: T::Boolean,
+          locale: BaseComponent::SymbolInput,
+          valid_range: T.nilable(T::Array[DateInput]),
+          year_range: YearRangeInput,
+          events: EventInputMap,
+          date_cell_render: DateCellRenderer,
+          month_cell_render: MonthCellRenderer,
+          header_render: HeaderRenderer,
+          disabled_date: DisabledDatePredicate,
+          static: T.nilable(T::Boolean),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         value: nil,
         default_value: nil,
@@ -53,53 +102,59 @@ module HakumiComponents
         static: nil,
         **html_options
       )
-        @value = parse_date(value)
-        @default_value = parse_date(default_value)
-        @mode = mode&.to_sym || :month
-        @fullscreen = fullscreen.nil? ? true : fullscreen
-        @show_week = show_week || false
-        @locale = locale&.to_sym || :en
-        @valid_range = normalize_valid_range(valid_range)
-        @year_range = year_range
-        @events = normalize_events(events)
-        @date_cell_render = date_cell_render
-        @month_cell_render = month_cell_render
-        @header_render = header_render
-        @disabled_date = disabled_date
-        @static = static.nil? ? has_custom_cell_render? : static
-        @html_options = html_options
+        @value = T.let(parse_date(value), T.nilable(Date))
+        @default_value = T.let(parse_date(default_value), T.nilable(Date))
+        @mode = T.let(normalize_symbol(mode, fallback: :month), Symbol)
+        @fullscreen = T.let(fullscreen.nil? ? true : fullscreen, T::Boolean)
+        @show_week = T.let(show_week, T::Boolean)
+        @locale = T.let(normalize_symbol(locale, fallback: :en), Symbol)
+        @valid_range = T.let(normalize_valid_range(valid_range), DateRange)
+        @year_range = T.let(year_range, YearRangeInput)
+        @events = T.let(normalize_events(events), EventsByDate)
+        @date_cell_render = T.let(date_cell_render, DateCellRenderer)
+        @month_cell_render = T.let(month_cell_render, MonthCellRenderer)
+        @header_render = T.let(header_render, HeaderRenderer)
+        @disabled_date = T.let(disabled_date, DisabledDatePredicate)
+        @static = T.let(static.nil? ? custom_cell_render? : static, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @display_model = T.let(nil, T.nilable(HakumiComponents::Calendar::DisplayModel))
 
         validate_props!
       end
 
-      def has_custom_cell_render?
-        @date_cell_render.respond_to?(:call) || @month_cell_render.respond_to?(:call)
+      sig { returns(T::Boolean) }
+      def custom_cell_render?
+        !@date_cell_render.nil? || !@month_cell_render.nil?
       end
 
+      sig { returns(T::Boolean) }
       def static?
         @static
       end
 
+      sig { returns(Date) }
       def current_date
         @value || @default_value || Date.today
       end
 
-      # Value that is actually selected (without Date.today fallback)
-      # Used for determining visual selection, not navigation
+      sig { returns(T.nilable(Date)) }
       def selected_value
         @value || @default_value
       end
 
+      sig { returns(Integer) }
       def current_year
         current_date.year
       end
 
+      sig { returns(Integer) }
       def current_month
         current_date.month
       end
 
+      sig { returns(String) }
       def calendar_classes
-        class_names(
+        component_classes(
           "calendar",
           {
             fullscreen: @fullscreen,
@@ -110,20 +165,24 @@ module HakumiComponents
             "mode-decade": decade_mode?,
             "show-week": @show_week
           },
-          @html_options[:class]
+          @html_options
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        base = {
-          class: calendar_classes,
-          data: data_attributes
-        }
-        merge_attributes(base, @html_options.except(:class))
+        merge_attributes(
+          {
+            class: calendar_classes,
+            data: data_attributes
+          },
+          @html_options.except(:class)
+        )
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
-        attrs = {
+        attrs = T.let({
           controller: "hakumi--calendar",
           "hakumi--calendar-mode-value": @mode,
           "hakumi--calendar-year-value": current_year,
@@ -131,317 +190,281 @@ module HakumiComponents
           "hakumi--calendar-fullscreen-value": @fullscreen,
           "hakumi--calendar-locale-value": @locale,
           "hakumi--calendar-static-value": @static
-        }
-        attrs["hakumi--calendar-events-value"] = events_to_json if @events.present?
+        }, Types::DataAttributes)
+        attrs["hakumi--calendar-events-value"] = events_to_json if events?
+        attrs["hakumi--calendar-valid-range-value"] = valid_range_to_json if @valid_range
         attrs
       end
 
+      sig { returns(String) }
+      def valid_range_to_json
+        start_date, end_date = T.must(@valid_range)
+        [ start_date&.iso8601, end_date&.iso8601 ].to_json
+      end
+
+      sig { returns(String) }
       def events_to_json
-        @events.transform_keys { |date| date.to_s }.transform_values do |events|
+        @events.transform_keys(&:iso8601).transform_values do |events|
           events.map do |event|
             {
-              id: event[:id],
-              type: event[:type]&.to_s || "default",
-              content: event[:content],
+              id: event.id,
+              type: event.type.to_s,
+              content: event.content,
               html: render_event_badge(event)
             }
           end
         end.to_json
       end
 
+      sig { params(event: HakumiComponents::Calendar::EventEntry).returns(String) }
       def render_event_badge(event)
         helpers.render(
           HakumiComponents::Badge::Component.new(
-            status: event[:type],
-            text: event[:content]
+            status: event.type,
+            text: event.content
           )
         ).to_s
       end
 
+      sig { returns(T::Boolean) }
       def month_mode?
         @mode == :month
       end
 
+      sig { returns(T::Boolean) }
       def year_mode?
         @mode == :year
       end
 
+      sig { returns(T::Boolean) }
       def quarter_mode?
         @mode == :quarter
       end
 
+      sig { returns(T::Boolean) }
       def decade_mode?
         @mode == :decade
       end
 
+      sig { returns(T::Boolean) }
       def fullscreen?
         @fullscreen
       end
 
+      sig { returns(T::Boolean) }
       def show_week?
         @show_week
       end
 
+      sig { returns(T::Boolean) }
       def show_header?
         @header_render != false
       end
 
+      sig { returns(T::Boolean) }
       def custom_header?
-        @header_render.respond_to?(:call)
+        @header_render.is_a?(Proc)
       end
 
-      # Show year select in month, year, and quarter modes (to change year)
+      sig { returns(T::Boolean) }
       def show_year_select?
         month_mode? || year_mode? || quarter_mode?
       end
 
-      # Show month select only in month mode (to change month)
+      sig { returns(T::Boolean) }
       def show_month_select?
         month_mode?
       end
 
-      # Show mode switch only for standalone calendar (not in date pickers)
+      sig { returns(T::Boolean) }
       def show_mode_switch?
         fullscreen? && !static?
       end
 
+      sig { returns(Types::RenderedContent) }
       def render_custom_header
-        return unless custom_header?
+        return nil unless @header_render.is_a?(Proc)
 
-        @header_render.call(
-          value: current_date,
-          type: @mode,
-          on_change: nil,
-          on_type_change: nil
-        )
+        @header_render.call(current_date, @mode, nil, nil)
+      end
+
+      sig { returns(HakumiComponents::Calendar::LocalePack) }
+      def locale_data
+        LOCALES.fetch(@locale, LOCALES.fetch(:en))
       end
 
+      sig { returns(T::Array[String]) }
       def weekday_names
-        locale_data[:days_short]
+        display_model.weekday_names
       end
 
+      sig { returns(T::Array[String]) }
       def month_names
-        locale_data[:months_full]
+        display_model.month_names
       end
 
+      sig { returns(T::Array[String]) }
       def month_names_short
-        locale_data[:months_short]
-      end
-
-      def locale_data
-        LOCALES[@locale] || LOCALES[:en]
+        display_model.month_names_short
       end
 
+      sig { returns(T::Array[HakumiComponents::Calendar::WeekRow]) }
       def weeks_in_month
-        @weeks_in_month ||= build_weeks_for_month(current_year, current_month)
+        display_model.weeks_in_month
       end
 
+      sig { returns(T::Array[HakumiComponents::Calendar::PanelEntry]) }
       def months_in_year
-        (1..12).map do |month|
-          {
-            month: month,
-            name: month_names[month - 1],
-            short_name: month_names_short[month - 1],
-            current: month == current_month && current_year == Date.today.year,
-            selected: selected_value && month == selected_value.month && current_year == selected_value.year
-          }
-        end
+        display_model.months_in_year
       end
 
+      sig { returns(T::Array[HakumiComponents::Calendar::PanelEntry]) }
       def quarters_in_year
-        today = Date.today
-        current_quarter = ((current_month - 1) / 3) + 1
-        selected_quarter = selected_value ? ((selected_value.month - 1) / 3) + 1 : nil
-
-        (1..4).map do |quarter|
-          {
-            quarter: quarter,
-            label: "Q#{quarter}",
-            current: quarter == current_quarter && current_year == today.year,
-            selected: selected_value && quarter == selected_quarter && current_year == selected_value.year
-          }
-        end
+        display_model.quarters_in_year
       end
 
+      sig { returns(T::Array[HakumiComponents::Calendar::PanelEntry]) }
       def years_in_decade
-        # Show 12 years: current decade (10 years) + 1 year before + 1 year after
-        decade_start = (current_year / 10) * 10
-        start_year = decade_start - 1
-        end_year = decade_start + 10
-        today = Date.today
-
-        (start_year..end_year).map do |year|
-          {
-            year: year,
-            current: year == today.year,
-            selected: selected_value && year == selected_value.year,
-            in_decade: year >= decade_start && year < decade_start + 10
-          }
-        end
+        display_model.years_in_decade
       end
 
+      sig { returns(String) }
       def decade_range_label
-        decade_start = (current_year / 10) * 10
-        "#{decade_start}-#{decade_start + 9}"
+        display_model.decade_range_label
       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)
-
-        base_year = current_year
-        ((base_year - 10)..(base_year + 10)).to_a
+        display_model.years_range
       end
 
+      sig { params(date: Date).returns(T::Boolean) }
       def date_disabled?(date)
-        return false unless @disabled_date.respond_to?(:call)
-
-        @disabled_date.call(date)
+        display_model.date_disabled?(date)
       end
 
+      sig { params(date: Date).returns(T::Boolean) }
       def date_in_valid_range?(date)
-        return true unless @valid_range
-
-        start_date, end_date = @valid_range
-        (start_date.nil? || date >= start_date) && (end_date.nil? || date <= end_date)
+        display_model.date_in_valid_range?(date)
       end
 
+      sig { params(date: Date).returns(Types::RenderedContent) }
       def render_date_cell(date)
-        return @date_cell_render.call(date) if @date_cell_render.respond_to?(:call)
+        return @date_cell_render.call(date) if @date_cell_render
 
         events_for_date(date)
       end
 
+      sig { params(date: Date).returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def events_for_date(date)
         items = @events[date]
         return nil if items.blank?
 
         safe_join(items.map do |item|
-          content_tag(:div, class: "hakumi-calendar-event hakumi-calendar-event-#{item[:type] || :default}") do
+          content_tag(:div, class: "hakumi-calendar-event hakumi-calendar-event-#{item.type}") do
             render HakumiComponents::Badge::Component.new(
-              status: item[:type] || :default,
-              text: item[:content]
+              status: item.type,
+              text: item.content
             )
           end
         end)
       end
 
-      def has_events?
-        @events.present? && @events.any?
+      sig { returns(T::Boolean) }
+      def events?
+        @events.any?
       end
 
+      sig { params(month: Integer).returns(Types::RenderedContent) }
       def render_month_cell(month)
-        return @month_cell_render.call(month) if @month_cell_render.respond_to?(:call)
+        return nil unless @month_cell_render
 
-        nil
+        @month_cell_render.call(month)
       end
 
-      def cell_classes(date)
-        classes = [ "hakumi-calendar-cell" ]
-        classes << "hakumi-calendar-cell-in-view" if date.month == current_month
-        classes << "hakumi-calendar-cell-today" if date == Date.today
-        classes << "hakumi-calendar-cell-selected" if selected_value && date == selected_value
-        classes << "hakumi-calendar-cell-disabled" if date_disabled?(date) || !date_in_valid_range?(date)
-        classes << "hakumi-calendar-cell-weekend" if date.saturday? || date.sunday?
-        classes.join(" ")
+      sig { params(cell: HakumiComponents::Calendar::DayCell).returns(String) }
+      def cell_classes(cell)
+        display_model.cell_classes(cell)
       end
 
-      def month_cell_classes(month_info)
-        classes = [ "hakumi-calendar-cell", "hakumi-calendar-cell-month" ]
-        classes << "hakumi-calendar-cell-selected" if month_info[:selected]
-        classes << "hakumi-calendar-cell-current" if month_info[:current]
-        classes.join(" ")
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry).returns(String) }
+      def month_cell_classes(entry)
+        display_model.month_cell_classes(entry)
       end
 
-      def quarter_cell_classes(quarter_info)
-        classes = [ "hakumi-calendar-cell", "hakumi-calendar-cell-quarter" ]
-        classes << "hakumi-calendar-cell-selected" if quarter_info[:selected]
-        classes << "hakumi-calendar-cell-current" if quarter_info[:current]
-        classes.join(" ")
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry).returns(String) }
+      def quarter_cell_classes(entry)
+        display_model.quarter_cell_classes(entry)
       end
 
-      def year_cell_classes(year_info)
-        classes = [ "hakumi-calendar-cell", "hakumi-calendar-cell-year" ]
-        classes << "hakumi-calendar-cell-selected" if year_info[:selected]
-        classes << "hakumi-calendar-cell-current" if year_info[:current]
-        classes << "hakumi-calendar-cell-disabled" unless year_info[:in_decade]
-        classes.join(" ")
+      sig { params(entry: HakumiComponents::Calendar::PanelEntry).returns(String) }
+      def year_cell_classes(entry)
+        display_model.year_cell_classes(entry)
       end
 
+      sig { params(date: Date).returns(Integer) }
       def week_number(date)
-        date.cweek
+        display_model.week_number(date)
       end
 
       private
 
+      sig { returns(HakumiComponents::Calendar::DisplayModel) }
+      def display_model
+        @display_model ||= HakumiComponents::Calendar::DisplayModel.new(
+          current_date: current_date,
+          selected_value: selected_value,
+          show_week: @show_week,
+          year_range: @year_range,
+          valid_range: @valid_range,
+          disabled_date: @disabled_date,
+          locale_data: locale_data
+        )
+      end
+
+      sig { void }
       def validate_props!
         validate_inclusion!(:mode, MODES)
         validate_inclusion!(:locale, LOCALES.keys)
       end
 
+      sig { params(value: DateInput).returns(T.nilable(Date)) }
       def parse_date(value)
         return nil if value.nil?
         return value if value.is_a?(Date)
-        return value.to_date if value.respond_to?(:to_date)
-
+        return value.to_date if value.is_a?(Time)
         Date.parse(value.to_s)
       rescue ArgumentError, TypeError
         nil
       end
 
+      sig { params(value: BaseComponent::SymbolInput, fallback: Symbol).returns(Symbol) }
+      def normalize_symbol(value, fallback:)
+        return fallback if value.nil?
+
+        symbol = value.to_sym
+        symbol.empty? ? fallback : symbol
+      rescue NoMethodError
+        fallback
+      end
+
+      sig { params(range: T.nilable(T::Array[DateInput])).returns(DateRange) }
       def normalize_valid_range(range)
         return nil unless range.is_a?(Array) && range.size == 2
 
         [ parse_date(range[0]), parse_date(range[1]) ]
       end
 
+      sig { params(events: EventInputMap).returns(EventsByDate) }
       def normalize_events(events)
-        return {} unless events.is_a?(Hash)
-
-        events.transform_keys { |k| parse_date(k) }.compact
-      end
-
-      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_week_number = selected_value&.cweek
-        selected_week_year = selected_value&.cwyear  # Use ISO week year, not calendar year
+        normalized = T.let({}, EventsByDate)
+        events.each do |key, items|
+          date = parse_date(key)
+          next if date.nil?
 
-        weeks = []
-        current = start_date
-
-        while current <= end_date
-          # Calculate Monday of this week (for ISO week number)
-          # current is Sunday (wday=0), so Monday is current + 1
-          monday = current.wday == 0 ? current + 1 : current - current.wday + 1
-          week_number = monday.cweek
-          week_year = monday.cwyear  # Use ISO week year, not calendar year
-
-          week = (0..6).map do |day_offset|
-            date = current + day_offset
-            {
-              date: date,
-              day: date.day,
-              in_month: date.month == month,
-              today: date == Date.today,
-              selected: selected_value && date == selected_value,
-              disabled: date_disabled?(date) || !date_in_valid_range?(date),
-              weekend: date.saturday? || date.sunday?
-            }
-          end
-          weeks << {
-            week_number: week_number,
-            week_selected: @show_week && selected_week_number == week_number && selected_week_year == week_year,
-            days: week
-          }
-          current += 7
+          normalized[date] = HakumiComponents::Calendar::EventEntry.coerce_all(items)
         end
-
-        weeks
+        normalized
       end
     end
   end