hakumi_components 0.1.17.pre → 0.1.19.pre

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 → 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

@@ -0,0 +1,121 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Card
+    class Component < HakumiComponents::BaseComponent
+      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,
+        type: nil,
+        href: nil,
+        target: nil,
+        **html_options
+      )
+        @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)
+
+        validate_props!
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        attrs = T.let({ class: classes }, Types::HtmlAttributes)
+        if link_card?
+          attrs[:href] = @href
+          attrs[:target] = @target if @target
+        end
+
+        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
+        component_classes(
+          "card",
+          {
+            bordered: @bordered,
+            hoverable: @hoverable,
+            small: @size == :small,
+            "type-inner": @type == :inner,
+            loading: @loading,
+            link: link_card?
+          },
+          @html_options
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def link_card?
+        !@href.nil? && @href.present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+<div <%= tag.attributes(wrapper_attributes) %>>
+  <%= content %>
+</div>

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

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Card
+    module Grid
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            hoverable: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          hoverable: true,
+          **html_options
+        )
+          @hoverable = T.let(cast_boolean(hoverable) != false, T::Boolean)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes(
+            {
+              class: classes
+            },
+            @html_options.except(:class)
+          )
+        end
+
+        private
+
+        sig { returns(String) }
+        def classes
+          component_classes("card-grid", { hoverable: @hoverable }, @html_options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+<div <%= tag.attributes(wrapper_attributes) %>>
+  <% if avatar_content.present? %>
+    <div class="hakumi-card-meta-avatar">
+      <%= avatar_content %>
+    </div>
+  <% end %>
+
+  <% if detail_content? %>
+    <div class="hakumi-card-meta-detail">
+      <% if title_content.present? %>
+        <div class="hakumi-card-meta-title">
+          <%= title_content %>
+        </div>
+      <% end %>
+
+      <% if description_content.present? %>
+        <div class="hakumi-card-meta-description">
+          <%= description_content %>
+        </div>
+      <% end %>
+    </div>
+  <% end %>
+</div>

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

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Card
+    module Meta
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            title: Types::Renderable,
+            description: Types::Renderable,
+            avatar: Types::Renderable,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          title: nil,
+          description: nil,
+          avatar: nil,
+          **html_options
+        )
+          @title = T.let(title, Types::Renderable)
+          @description = T.let(description, Types::Renderable)
+          @avatar = T.let(avatar, Types::Renderable)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes({ class: classes }, @html_options.except(:class))
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def avatar_content
+          render_value(@avatar)
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def title_content
+          render_value(@title)
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def description_content
+          render_value(@description)
+        end
+
+        sig { returns(T::Boolean) }
+        def detail_content?
+          title_content.present? || description_content.present?
+        end
+
+        private
+
+        sig { returns(String) }
+        def classes
+          component_classes("card-meta", {}, @html_options)
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/carousel/autoplay_config.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Carousel
+    class AutoplayConfig
+      extend T::Sig
+
+      sig { params(enabled: T::Boolean, dot_duration: T::Boolean).void }
+      def initialize(enabled:, dot_duration: false)
+        @enabled = T.let(enabled, T::Boolean)
+        @dot_duration = T.let(dot_duration, T::Boolean)
+      end
+
+      sig { returns(T::Boolean) }
+      attr_reader :enabled, :dot_duration
+
+      sig { params(value: T.any(T::Boolean, Types::HtmlAttributes)).returns(HakumiComponents::Carousel::AutoplayConfig) }
+      def self.coerce(value)
+        return new(enabled: value) if value == true || value == false
+
+        dot_duration = value[:dot_duration]
+        new(enabled: true, dot_duration: dot_duration == true)
+      end
+    end
+  end
+end