rails-datepicker 0.1.0

data/lib/generators/rails_datepicker/install_generator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsDatepicker
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :skip_tailwind, type: :boolean, default: false, desc: "Skip Tailwind CSS integration"
+
+      def copy_initializer
+        template "initializer.rb.tt", "config/initializers/rails_datepicker.rb"
+      end
+
+      def install_javascript
+        copy_file gem_file("app/javascript/controllers/rails_datepicker_controller.js"), "app/javascript/controllers/rails_datepicker_controller.js"
+        copy_file gem_file("app/javascript/rails-datepicker/calendar.js"), "app/javascript/rails-datepicker/calendar.js"
+        unless importmap?
+          gsub_file "app/javascript/controllers/rails_datepicker_controller.js",
+            'from "rails-datepicker/calendar"',
+            'from "../rails-datepicker/calendar.js"'
+        end
+      end
+
+      def configure_importmap
+        return unless importmap?
+        return if File.read(destination_path("config/importmap.rb")).include?('pin "rails-datepicker/calendar"')
+
+        append_to_file "config/importmap.rb", <<~RUBY
+
+          # rails-datepicker (the controller itself is discovered by stimulus-rails)
+          pin "rails-datepicker/calendar", to: "rails-datepicker/calendar.js"
+        RUBY
+      end
+
+      def install_tailwind
+        return if options[:skip_tailwind]
+
+        stylesheet = tailwind_stylesheet
+        component_path = if stylesheet
+          File.join(File.dirname(stylesheet), "rails_datepicker.css")
+        else
+          "app/assets/tailwind/rails_datepicker.css"
+        end
+        copy_file gem_file("app/assets/stylesheets/rails_datepicker.css"), component_path
+        if stylesheet
+          import = '@import "./rails_datepicker.css";'
+          append_to_file(stylesheet, "\n#{import}\n") unless File.read(destination_path(stylesheet)).include?(import)
+        else
+          say "Tailwind entrypoint not found. Import app/assets/tailwind/rails_datepicker.css from your Tailwind CSS 4 stylesheet.", :yellow
+        end
+      end
+
+      def finish
+        say "Rails Datepicker installed. Restart the asset watcher before testing the field.", :green
+      end
+
+      private
+
+      def gem_file(relative)
+        File.expand_path("../../../#{relative}", __dir__)
+      end
+
+      def destination_path(relative)
+        File.join(destination_root, relative)
+      end
+
+      def tailwind_stylesheet
+        known = %w[
+          app/assets/tailwind/application.css
+          app/assets/stylesheets/application.tailwind.css
+        ].find { |path| File.exist?(destination_path(path)) }
+        return known if known
+
+        generic = "app/assets/stylesheets/application.css"
+        return unless File.exist?(destination_path(generic))
+
+        generic if File.read(destination_path(generic)).match?(/@import\s+["']tailwindcss["']/)
+      end
+
+      def importmap?
+        File.exist?(destination_path("config/importmap.rb"))
+      end
+    end
+  end
+end

data/lib/generators/rails_datepicker/templates/initializer.rb.tt

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RailsDatepicker.configure do |config|
+  config.default_calendar = :ethiopian
+  config.default_locale = :am
+  config.date_format = "YYYY-MM-DD"
+  config.theme = :auto
+  config.week_start = :sunday
+end

data/lib/rails-datepicker.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Bundler auto-requires the gem name. Keep the public Ruby require idiomatic too.
+require_relative "rails_datepicker"

data/lib/rails_datepicker/calendar.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "date"
+
+module RailsDatepicker
+  module Calendar
+    class InvalidDate < ArgumentError; end
+
+    ETHIOPIAN_ANCHOR_YEAR = 2015
+    ETHIOPIAN_ANCHOR_DATE = Date.new(2022, 9, 11, Date::GREGORIAN)
+
+    module_function
+
+    def ethiopian_leap_year?(year)
+      Integer(year) % 4 == 3
+    end
+
+    def gregorian_leap_year?(year)
+      Date.gregorian_leap?(Integer(year))
+    end
+
+    def ethiopian_month_length(year, month)
+      year = Integer(year)
+      month = Integer(month)
+      raise InvalidDate, "Ethiopian month must be between 1 and 13" unless (1..13).cover?(month)
+
+      return 30 if month <= 12
+
+      ethiopian_leap_year?(year) ? 6 : 5
+    end
+
+    def valid_ethiopian_date?(year, month, day)
+      year = Integer(year)
+      month = Integer(month)
+      day = Integer(day)
+      year.positive? && day.between?(1, ethiopian_month_length(year, month))
+    rescue ArgumentError, TypeError
+      false
+    end
+
+    def ethiopian_to_gregorian(year, month, day)
+      year, month, day = [year, month, day].map { |part| Integer(part) }
+      raise InvalidDate, "invalid Ethiopian date" unless valid_ethiopian_date?(year, month, day)
+
+      new_year = ethiopian_new_year(year)
+      new_year + ((month - 1) * 30) + day - 1
+    end
+
+    def gregorian_to_ethiopian(value, month = nil, day = nil)
+      date = coerce_gregorian(value, month, day)
+      raise InvalidDate, "date predates the Ethiopian calendar" if date < ethiopian_new_year(1)
+
+      ethiopian_year = [date.year - 7, 1].max
+      ethiopian_year -= 1 while date < ethiopian_new_year(ethiopian_year)
+      ethiopian_year += 1 while date >= ethiopian_new_year(ethiopian_year + 1)
+      offset = (date - ethiopian_new_year(ethiopian_year)).to_i
+
+      [ethiopian_year, (offset / 30) + 1, (offset % 30) + 1]
+    end
+
+    def ethiopian_new_year(ethiopian_year)
+      ethiopian_year = Integer(ethiopian_year)
+      raise InvalidDate, "Ethiopian year must be positive" unless ethiopian_year.positive?
+
+      ETHIOPIAN_ANCHOR_DATE + days_before_ethiopian_year(ethiopian_year) -
+        days_before_ethiopian_year(ETHIOPIAN_ANCHOR_YEAR)
+    end
+
+    def days_before_ethiopian_year(year)
+      (365 * (year - 1)) + (year / 4)
+    end
+    private_class_method :days_before_ethiopian_year
+
+    def parse_iso(value)
+      match = /\A(\d{4,})-(\d{2})-(\d{2})\z/.match(value.to_s)
+      raise InvalidDate, "date must use YYYY-MM-DD" unless match
+
+      Date.new(*match.captures.map(&:to_i), Date::GREGORIAN)
+    rescue Date::Error
+      raise InvalidDate, "invalid Gregorian date"
+    end
+
+    def format_ethiopian(date, format = "YYYY-MM-DD", numerals: false)
+      year, month, day = gregorian_to_ethiopian(date)
+      formatted = apply_format(format, year, month, day)
+      numerals ? to_ethiopic_numerals(formatted) : formatted
+    end
+
+    def format_gregorian(date, format = "YYYY-MM-DD", numerals: false)
+      date = coerce_gregorian(date)
+      formatted = apply_format(format, date.year, date.month, date.day)
+      numerals ? to_ethiopic_numerals(formatted) : formatted
+    end
+
+    def to_ethiopic_numerals(value)
+      value.to_s.gsub(/\d+/) { |digits| encode_ethiopic_integer(digits.to_i) }
+    end
+
+    def apply_format(format, year, month, day)
+      format.to_s.gsub("YYYY", year.to_s.rjust(4, "0"))
+        .gsub("MM", month.to_s.rjust(2, "0"))
+        .gsub("DD", day.to_s.rjust(2, "0"))
+    end
+    private_class_method :apply_format
+
+    def coerce_gregorian(value, month = nil, day = nil)
+      return Date.new(Integer(value), Integer(month), Integer(day), Date::GREGORIAN) unless month.nil? || day.nil?
+      return value if value.is_a?(Date)
+      return value.to_date if value.respond_to?(:to_date)
+
+      parse_iso(value)
+    rescue Date::Error, ArgumentError, TypeError
+      raise InvalidDate, "invalid Gregorian date"
+    end
+    private_class_method :coerce_gregorian
+
+    ETHIOPIC_ONES = ["", "፩", "፪", "፫", "፬", "፭", "፮", "፯", "፰", "፱"].freeze
+    ETHIOPIC_TENS = ["", "፲", "፳", "፴", "፵", "፶", "፷", "፸", "፹", "፺"].freeze
+
+    def encode_ethiopic_integer(number)
+      return "0" if number.zero?
+
+      groups = []
+      while number.positive?
+        groups.unshift(number % 100)
+        number /= 100
+      end
+
+      groups.each_with_index.filter_map do |group, index|
+        power = groups.length - index - 1
+        next if group.zero?
+
+        coefficient = if group == 1 && power.positive?
+                        ""
+                      else
+                        "#{ETHIOPIC_TENS[group / 10]}#{ETHIOPIC_ONES[group % 10]}"
+                      end
+        marker = if power.zero?
+                   ""
+                 elsif power.odd?
+                   "፼" * (power / 2) + "፻"
+                 else
+                   "፼" * (power / 2)
+                 end
+        "#{coefficient}#{marker}"
+      end.join
+    end
+    private_class_method :encode_ethiopic_integer
+  end
+end

data/lib/rails_datepicker/configuration.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RailsDatepicker
+  class Configuration
+    CALENDARS = %i[ethiopian gregorian].freeze
+    LOCALES = %i[am en].freeze
+    THEMES = %i[auto light dark].freeze
+    WEEK_STARTS = %i[sunday monday].freeze
+
+    attr_reader :default_calendar, :default_locale, :date_format, :theme, :week_start
+
+    def initialize
+      @default_calendar = :ethiopian
+      @default_locale = :am
+      @date_format = "YYYY-MM-DD"
+      @theme = :auto
+      @week_start = :sunday
+    end
+
+    def default_calendar=(value)
+      @default_calendar = validate!(:calendar, value, CALENDARS)
+    end
+
+    def default_locale=(value)
+      @default_locale = validate!(:locale, value, LOCALES)
+    end
+
+    def theme=(value)
+      @theme = validate!(:theme, value, THEMES)
+    end
+
+    def week_start=(value)
+      @week_start = validate!(:week_start, value, WEEK_STARTS)
+    end
+
+    def date_format=(value)
+      format = value.to_s
+      tokens = format.scan(/YYYY|MM|DD/)
+      unless tokens.length == 3 && tokens.uniq.length == 3
+        raise ArgumentError, "date_format must contain YYYY, MM, and DD exactly once"
+      end
+
+      @date_format = format
+    end
+
+    private
+
+    def validate!(name, value, allowed)
+      normalized = value.to_sym
+      return normalized if allowed.include?(normalized)
+
+      raise ArgumentError, "invalid #{name}: #{value.inspect}; expected one of #{allowed.join(', ')}"
+    end
+  end
+end

data/lib/rails_datepicker/engine.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+require_relative "form_helper"
+
+module RailsDatepicker
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsDatepicker
+
+    initializer "rails_datepicker.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include RailsDatepicker::FormHelper
+      end
+      ActionView::Helpers::FormBuilder.include RailsDatepicker::FormBuilder
+    end
+
+    initializer "rails_datepicker.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << root.join("config/importmap.rb")
+        app.config.assets.paths << root.join("app/javascript") if app.config.respond_to?(:assets)
+      end
+    end
+
+    config.after_initialize do
+      if defined?(SimpleForm) || Gem.loaded_specs.key?("simple_form")
+        require "simple_form" unless defined?(SimpleForm)
+        require "rails_datepicker/simple_form_input"
+      end
+    end
+  end
+end

data/lib/rails_datepicker/form_helper.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsDatepicker
+  module FormHelper
+    FIELD_OPTIONS = %i[
+      calendar display_calendar locale date_format format theme week_start ethiopic_numerals
+      inline min max disabled_dates readonly years_before years_after
+    ].freeze
+
+    def rails_datepicker_field(object_name, method, options = {})
+      object = options.delete(:object) || rails_datepicker_object_for(object_name)
+      builder = ActionView::Helpers::FormBuilder.new(object_name, object, self, {})
+      builder.datepicker_field(method, options)
+    end
+
+    private
+
+    def rails_datepicker_object_for(object_name)
+      root = object_name.to_s.sub(/\[.*\]\z/, "")
+      instance_variable_get("@#{root}")
+    end
+  end
+
+  module FormBuilder
+    def datepicker_field(method, options = {})
+      config = RailsDatepicker.configuration
+      picker = extract_picker_options(options, config)
+      html_options = options.dup
+      value = html_options.key?(:value) ? html_options.delete(:value) : object&.public_send(method)
+      iso_value = canonical_iso(value)
+      visible_value = display_value(iso_value, picker)
+      base_id = html_options.delete(:id) || field_id(method)
+      canonical_id = "#{base_id}_gregorian"
+      disabled = html_options[:disabled]
+      required = html_options[:required]
+      readonly = picker[:readonly] || html_options.delete(:readonly)
+      aria_options = html_options.delete(:aria)
+      errors = object.respond_to?(:errors) ? object.errors[method] : []
+      invalid = errors.any?
+
+      data = stimulus_data(picker, iso_value)
+      wrapper_classes = ["rdp", "rdp--#{picker[:theme]}", ("rdp--inline" if picker[:inline])].compact.join(" ")
+
+      @template.content_tag(:div, class: wrapper_classes, lang: picker[:locale], data: data) do
+        canonical = hidden_field(method,
+          id: canonical_id,
+          value: iso_value,
+          disabled: disabled,
+          data: { rails_datepicker_target: "canonical" })
+
+        visible_options = html_options.merge(
+          id: base_id,
+          name: nil,
+          value: visible_value,
+          readonly: readonly,
+          required: required,
+          disabled: disabled,
+          autocomplete: "off",
+          inputmode: "numeric",
+          role: "combobox",
+          aria: input_aria(base_id, picker, invalid, aria_options),
+          class: ["rdp__input", html_options[:class]].compact.join(" "),
+          data: merge_data(html_options[:data],
+            rails_datepicker_target: "input",
+            action: "input->rails-datepicker#input blur->rails-datepicker#validate keydown->rails-datepicker#inputKeydown")
+        )
+        visible_options.delete(:class) if visible_options[:class].empty?
+        input = text_field(method, visible_options)
+        trigger = picker[:inline] ? nil : calendar_trigger(base_id, disabled, picker[:locale])
+        input_group = @template.content_tag(:div, @template.safe_join([input, trigger].compact), class: "rdp__input-group")
+        panel = calendar_panel(base_id, picker, disabled)
+        error = if invalid
+          @template.content_tag(:p, errors.to_sentence, id: "#{base_id}_error", class: "rdp__error", role: "alert")
+        end
+
+        @template.safe_join([canonical, input_group, panel, error].compact)
+      end
+    end
+
+    private
+
+    def extract_picker_options(options, config)
+      date_format = options.delete(:date_format) || options.delete(:format) || config.date_format
+      validate_date_format!(date_format)
+      min = constraint_iso(options.delete(:min), :min)
+      max = constraint_iso(options.delete(:max), :max)
+      raise ArgumentError, "min must not be after max" if !min.empty? && !max.empty? && min > max
+      years_before = Integer(options.delete(:years_before) || 100)
+      years_after = Integer(options.delete(:years_after) || 20)
+      raise ArgumentError, "year ranges must be non-negative" if years_before.negative? || years_after.negative?
+
+      calendar = options.delete(:calendar) || config.default_calendar
+      {
+        calendar: picker_enum!(:calendar, calendar, Configuration::CALENDARS),
+        display_calendar: (picker_enum!(:display_calendar, options.delete(:display_calendar), Configuration::CALENDARS) if options[:display_calendar]),
+        locale: picker_enum!(:locale, options.delete(:locale) || config.default_locale, Configuration::LOCALES),
+        date_format: date_format,
+        theme: picker_enum!(:theme, options.delete(:theme) || config.theme, Configuration::THEMES),
+        week_start: picker_enum!(:week_start, options.delete(:week_start) || config.week_start, Configuration::WEEK_STARTS),
+        ethiopic_numerals: !!options.delete(:ethiopic_numerals),
+        inline: !!options.delete(:inline),
+        min: min,
+        max: max,
+        disabled_dates: Array(options.delete(:disabled_dates)).map { |date| constraint_iso(date, :disabled_dates) },
+        readonly: !!options.delete(:readonly),
+        years_before: years_before,
+        years_after: years_after
+      }
+    end
+
+    def validate_date_format!(format)
+      tokens = format.to_s.scan(/YYYY|MM|DD/)
+      return if tokens.length == 3 && tokens.uniq.length == 3
+
+      raise ArgumentError, "date_format must contain YYYY, MM, and DD exactly once"
+    end
+
+    def constraint_iso(value, name)
+      return "" if value.nil? || value == ""
+
+      result = canonical_iso(value)
+      RailsDatepicker::Calendar.parse_iso(result).strftime("%Y-%m-%d")
+    rescue RailsDatepicker::Calendar::InvalidDate
+      raise ArgumentError, "#{name} must be a Gregorian date or YYYY-MM-DD value"
+    end
+
+    def picker_enum!(name, value, allowed)
+      normalized = value.to_sym
+      return normalized if allowed.include?(normalized)
+
+      raise ArgumentError, "invalid #{name}: #{value.inspect}; expected one of #{allowed.join(', ')}"
+    end
+
+    def stimulus_data(picker, iso_value)
+      {
+        controller: "rails-datepicker",
+        rails_datepicker_calendar_value: picker[:calendar],
+        rails_datepicker_display_calendar_value: picker[:display_calendar],
+        rails_datepicker_locale_value: picker[:locale],
+        rails_datepicker_format_value: picker[:date_format],
+        rails_datepicker_theme_value: picker[:theme],
+        rails_datepicker_week_start_value: picker[:week_start],
+        rails_datepicker_ethiopic_numerals_value: picker[:ethiopic_numerals],
+        rails_datepicker_inline_value: picker[:inline],
+        rails_datepicker_min_value: picker[:min].to_s,
+        rails_datepicker_max_value: picker[:max].to_s,
+        rails_datepicker_disabled_dates_value: picker[:disabled_dates].to_json,
+        rails_datepicker_years_before_value: picker[:years_before],
+        rails_datepicker_years_after_value: picker[:years_after],
+        rails_datepicker_selected_value: iso_value.to_s
+      }
+    end
+
+    def calendar_trigger(base_id, disabled, locale)
+      @template.button_tag(
+        type: "button",
+        class: "rdp__trigger",
+        disabled: disabled,
+        aria: { label: translate("open_calendar", locale), controls: "#{base_id}_calendar" },
+        data: { rails_datepicker_label: "open_calendar", rails_datepicker_target: "trigger", action: "rails-datepicker#toggle" }
+      ) do
+        @template.content_tag(:svg, class: "rdp__icon", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", aria: { hidden: "true" }) do
+          @template.safe_join([
+            @template.tag.path(d: "M8 2v4M16 2v4M3 10h18", stroke_width: 2, stroke_linecap: "round"),
+            @template.tag.rect(x: 3, y: 5, width: 18, height: 16, rx: 2, stroke_width: 2)
+          ])
+        end
+      end
+    end
+
+    def calendar_panel(base_id, picker, disabled)
+      @template.content_tag(:div,
+        id: "#{base_id}_calendar",
+        class: "rdp__popover",
+        hidden: !picker[:inline],
+        role: "dialog",
+        aria: { modal: "false", label: translate("choose_date", picker[:locale]) },
+        data: { rails_datepicker_label: "choose_date", rails_datepicker_target: "popover", action: "keydown->rails-datepicker#calendarKeydown" }) do
+        @template.safe_join([
+          calendar_header(picker[:locale], disabled),
+          @template.content_tag(:div, "", class: "rdp__weekdays", role: "row", data: { rails_datepicker_target: "weekdays" }),
+          @template.content_tag(:div, "", class: "rdp__grid", role: "grid", data: { rails_datepicker_target: "grid" }),
+          calendar_footer(picker[:locale], disabled)
+        ])
+      end
+    end
+
+    def calendar_header(locale, disabled)
+      @template.content_tag(:div, class: "rdp__header") do
+        @template.safe_join([
+          nav_button("previous_month", "previousMonth", "‹", locale, disabled),
+          @template.content_tag(:div, class: "rdp__selectors") do
+            @template.safe_join([
+              @template.select_tag(nil, "", class: "rdp__select", disabled: disabled, aria: { label: translate("month", locale) }, data: { rails_datepicker_label: "month", rails_datepicker_target: "monthSelect", action: "change->rails-datepicker#selectMonth" }),
+              @template.select_tag(nil, "", class: "rdp__select", disabled: disabled, aria: { label: translate("year", locale) }, data: { rails_datepicker_label: "year", rails_datepicker_target: "yearSelect", action: "change->rails-datepicker#selectYear" })
+            ])
+          end,
+          nav_button("next_month", "nextMonth", "›", locale, disabled)
+        ])
+      end
+    end
+
+    def calendar_footer(locale, disabled)
+      @template.content_tag(:div, class: "rdp__footer") do
+        @template.safe_join([
+          @template.button_tag(translate("today", locale), type: "button", class: "rdp__footer-button", disabled: disabled, data: { rails_datepicker_text: "today", action: "rails-datepicker#today" }),
+          @template.button_tag(translate("clear", locale), type: "button", class: "rdp__footer-button", disabled: disabled, data: { rails_datepicker_text: "clear", action: "rails-datepicker#clear" }),
+          @template.button_tag("", type: "button", class: "rdp__locale-toggle", disabled: disabled, data: { rails_datepicker_target: "localeToggle", action: "rails-datepicker#switchLocale" }),
+          @template.button_tag("", type: "button", class: "rdp__calendar-toggle", disabled: disabled, data: { rails_datepicker_target: "calendarToggle", action: "rails-datepicker#switchCalendar" })
+        ])
+      end
+    end
+
+    def nav_button(label, action, glyph, locale, disabled)
+      @template.button_tag(glyph, type: "button", class: "rdp__nav", disabled: disabled, aria: { label: translate(label, locale) }, data: { rails_datepicker_label: label, action: "rails-datepicker##{action}" })
+    end
+
+    def canonical_iso(value)
+      return "" if value.nil? || value == ""
+
+      date = value.respond_to?(:to_date) ? value.to_date : RailsDatepicker::Calendar.parse_iso(value)
+      date.strftime("%Y-%m-%d")
+    rescue RailsDatepicker::Calendar::InvalidDate, Date::Error
+      value.to_s
+    end
+
+    def display_value(iso_value, picker)
+      return "" if iso_value.empty?
+
+      date = RailsDatepicker::Calendar.parse_iso(iso_value)
+      if (picker[:display_calendar] || picker[:calendar]) == :ethiopian
+        RailsDatepicker::Calendar.format_ethiopian(date, picker[:date_format], numerals: picker[:ethiopic_numerals])
+      else
+        RailsDatepicker::Calendar.format_gregorian(date, picker[:date_format], numerals: picker[:ethiopic_numerals])
+      end
+    rescue RailsDatepicker::Calendar::InvalidDate
+      iso_value
+    end
+
+    def input_aria(base_id, picker, invalid, existing)
+      supplied = (existing || {}).to_h.transform_keys(&:to_sym)
+      describedby = [supplied.delete(:describedby), ("#{base_id}_error" if invalid)].compact.join(" ")
+      aria = {
+        autocomplete: "none",
+        controls: "#{base_id}_calendar",
+        expanded: picker[:inline] ? "true" : "false",
+        haspopup: "dialog",
+        invalid: invalid.to_s
+      }.merge(supplied)
+      aria[:invalid] = "true" if invalid
+      aria[:describedby] = describedby unless describedby.empty?
+      aria
+    end
+
+    def merge_data(existing, additions)
+      (existing || {}).to_h.transform_keys(&:to_sym).merge(additions) do |key, old_value, new_value|
+        key.to_sym == :action ? "#{old_value} #{new_value}" : new_value
+      end
+    end
+
+    def translate(key, locale)
+      I18n.t("rails_datepicker.#{key}", locale: locale, default: key.to_s.tr("_", " ").capitalize)
+    end
+  end
+end

data/lib/rails_datepicker/simple_form_input.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+return unless defined?(SimpleForm::Inputs::Base)
+
+class RailsDatepickerInput < SimpleForm::Inputs::Base
+  PICKER_KEYS = RailsDatepicker::FormHelper::FIELD_OPTIONS
+
+  def input(wrapper_options = nil)
+    merged = merge_wrapper_options(input_html_options, wrapper_options)
+    picker_options = options.slice(*PICKER_KEYS)
+    @builder.datepicker_field(attribute_name, picker_options.merge(merged))
+  end
+
+  def input_type
+    :string
+  end
+end

data/lib/rails_datepicker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsDatepicker
+  VERSION = "0.1.0"
+end

data/lib/rails_datepicker.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "rails_datepicker/version"
+require_relative "rails_datepicker/configuration"
+require_relative "rails_datepicker/calendar"
+
+module RailsDatepicker
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+require_relative "rails_datepicker/engine" if defined?(Rails::Engine)

data/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "rails-datepicker",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./calendar": "./app/javascript/rails-datepicker/calendar.js",
+    "./controller": "./app/javascript/controllers/rails_datepicker_controller.js"
+  },
+  "scripts": {
+    "test": "node --test test/javascript/**/*_test.js",
+    "build:css": "tailwindcss -i test/fixtures/tailwind.css -o test/tmp/rails_datepicker.css --minify"
+  },
+  "peerDependencies": {
+    "@hotwired/stimulus": "^3.2.0"
+  },
+  "devDependencies": {
+    "@hotwired/stimulus": "3.2.2",
+    "@tailwindcss/cli": "^4.3.0",
+    "tailwindcss": "^4.3.0"
+  }
+}