lato_cms 3.0.0

data/app/helpers/lato_cms/pages_helper.rb

@@ -0,0 +1,69 @@
+module LatoCms
+  module PagesHelper
+    BUILTIN_FIELD_TYPES = %w[string textarea text number date datetime boolean select multiselect color json file image gallery].freeze
+
+    # Returns the path for an Active Storage attachment.
+    # Using main_app avoids the missing `attachment_path` error inside the engine.
+    def lato_cms_attachment_path(attachment)
+      main_app.rails_blob_path(attachment.blob, only_path: true)
+    rescue StandardError
+      '#'
+    end
+
+    def lato_cms_page_locale(page)
+      content_tag(:span, class: 'badge bg-secondary') do
+        concat locale_to_flag(page.locale)
+        concat " #{page.locale.upcase}"
+      end
+    end
+
+    def lato_cms_page_actions(page, show_edit: false, show_delete: false, hide_show: false)
+      btn_group = capture do
+        content_tag(:div, class: 'btn-group btn-group-sm') do
+          concat(link_to(t('lato_cms.cta_show'), lato_cms.pages_show_path(page), class: 'btn btn-primary')) unless hide_show
+          if show_edit
+            concat link_to(t('lato_cms.cta_edit'), lato_cms.pages_update_path(page), class: 'btn btn-secondary',
+              data: { lato_action_target: 'trigger', turbo_frame: dom_id(page, 'form'), action_title: t('lato_cms.page_update_title') })
+          end
+          if show_delete
+            concat link_to(t('lato_cms.cta_delete'), lato_cms.pages_destroy_action_path(page), class: 'btn btn-danger',
+              data: { turbo_method: 'DELETE', turbo_confirm: t('lato_cms.cta_delete_confirm') })
+          end
+        end
+      end
+
+      content_tag(:div, class: 'd-flex align-items-center gap-2') do
+        if page.frontend_url.blank?
+          concat content_tag(:span, t('lato_cms.action_view_frontend'), class: 'btn btn-sm btn-link px-0 disabled text-muted')
+        else
+          concat link_to(t('lato_cms.action_view_frontend'), page.frontend_url, class: 'btn btn-sm btn-link px-0', target: '_blank')
+        end
+        concat btn_group
+      end
+    end
+
+    def lato_cms_render_field(field_id:, field_config:, page_field:)
+      render resolve_lato_cms_field_partial(field_config),
+        field_id: field_id,
+        field_config: field_config,
+        page_field: page_field
+    rescue ActionView::MissingTemplate => e
+      content_tag(:div, class: 'alert alert-danger mb-0') do
+        "Field '#{field_id}' render error: #{e.message}"
+      end
+    end
+
+    private
+
+    def resolve_lato_cms_field_partial(field_config)
+      type = (field_config['type'] || 'string').to_s
+      return "lato_cms/pages/fields/#{type}" if BUILTIN_FIELD_TYPES.include?(type)
+      return 'lato_cms/pages/fields/string' unless type == 'custom'
+
+      render_path = field_config['render'].to_s.strip
+      return 'lato_cms/pages/fields/string' if render_path.blank?
+
+      render_path
+    end
+  end
+end

data/app/jobs/lato_cms/application_job.rb

@@ -0,0 +1,4 @@
+module LatoCms
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/lato_cms/application_mailer.rb

@@ -0,0 +1,6 @@
+module LatoCms
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/lato_cms/page.rb

@@ -0,0 +1,133 @@
+module LatoCms
+  class Page < ApplicationRecord
+    include LatoSpaces::Associable
+    include LatoSpaces::AssociableRequired
+    include LatoSpaces::AssociableUnique
+
+    attr_accessor :actions
+
+    validates :title, presence: true
+    validates :locale, presence: true, inclusion: { in: ->(page) { LatoCms.config.locales.map(&:to_s) } }
+    validates :permalink, presence: true, format: { with: /\A\/([a-zA-Z0-9\-_]+(\/[a-zA-Z0-9\-_]+)*)?\z/, message: 'must start with / and contain only letters, numbers, hyphens, and underscores' }
+    validate :permalink_unique_within_lato_spaces_group
+
+    before_validation :generate_permalink, on: :create
+
+    has_many :fields, class_name: 'LatoCms::PageField', dependent: :destroy
+
+    def template
+      LatoCms::TemplateManager.find_template(template_id)
+    end
+
+    def template_name
+      template&.dig('name') || template_id
+    end
+
+    def template_available?
+      template_id.blank? || template.present?
+    end
+
+    def template_components
+      return [] unless template
+      LatoCms::TemplateManager.resolve_template_components(template)
+    end
+
+    def component_enabled?(template_component_id, default: true)
+      value = (component_states || {})[template_component_id.to_s]
+      return default if value.nil?
+
+      value == true
+    end
+
+    def component_required?(template_component_id)
+      tc = template_components.find { |component| component[:template_component_id] == template_component_id.to_s }
+      tc && tc[:required] == true
+    end
+
+    def component_effectively_enabled?(template_component_id, default: true)
+      return true if component_required?(template_component_id)
+
+      component_enabled?(template_component_id, default: default)
+    end
+
+    def set_component_enabled(template_component_id, enabled)
+      key = template_component_id.to_s
+      self.component_states = (component_states || {}).merge(key => ActiveModel::Type::Boolean.new.cast(enabled))
+    end
+
+    def as_json(options = {})
+      data = {
+        id: id,
+        title: title,
+        permalink: permalink,
+        locale: locale,
+        template_id: template_id,
+        template_name: template_name,
+        frontend_url: frontend_url,
+        created_at: created_at,
+        updated_at: updated_at
+      }
+
+      if options[:include_fields]
+        fields.load unless fields.loaded?
+        data[:fields] = build_fields_json(template_components.select { |tc| component_effectively_enabled?(tc[:template_component_id]) })
+      end
+
+      data
+    end
+
+    private
+
+    def build_fields_json(comps)
+      fields_by_component = fields.group_by(&:template_component_id)
+
+      comps.each_with_object({}) do |tc, hash|
+        component_fields = (fields_by_component[tc[:template_component_id]] || []).index_by(&:field_id)
+
+        hash[tc[:template_component_id]] = {
+          component_id: tc[:component_id],
+          name: tc[:name],
+          fields: (tc[:fields] || {}).each_with_object({}) do |(fid, fconfig), fhash|
+            field = component_fields[fid.to_s]
+            fhash[fid] = field ? field.as_json : empty_field_json(fid.to_s, fconfig)
+          end
+        }
+      end
+    end
+
+    def empty_field_json(fid, fconfig)
+      {
+        id: nil,
+        field_id: fid,
+        field_type: fconfig['type'] || 'string',
+        field_name: fconfig['name'] || fid.humanize,
+        required: fconfig['required'] == true,
+        value: nil,
+        attachments: []
+      }
+    end
+
+    def generate_permalink
+      return if title.blank?
+      return if permalink.present?
+
+      base = "/#{title.parameterize}"
+      candidate = base
+      counter = 1
+
+      while LatoCms::Page.for_lato_spaces_group(self.lato_spaces_group_id).where(permalink: candidate).where.not(id: id).exists?
+        candidate = "#{base}-#{counter}"
+        counter += 1
+      end
+
+      self.permalink = candidate
+    end
+
+    def permalink_unique_within_lato_spaces_group
+      other_pages_with_same_permalink = LatoCms::Page.for_lato_spaces_group(self.lato_spaces_group_id).where(permalink: permalink).where.not(id: id)
+      if other_pages_with_same_permalink.count.positive?
+        errors.add(:permalink, :taken)
+      end
+    end
+  end
+end

data/app/models/lato_cms/page_field.rb

@@ -0,0 +1,113 @@
+module LatoCms
+  class PageField < ApplicationRecord
+    belongs_to :page, class_name: 'LatoCms::Page'
+
+    has_many_attached :files
+
+    validates :template_id, presence: true
+    validates :template_component_id, presence: true
+    validates :component_id, presence: true
+    validates :field_id, presence: true
+    validates :field_id, uniqueness: { scope: [:page_id, :template_component_id] }
+
+    before_save :parse_value
+
+    def parsed_value
+      return nil if value.blank?
+
+      case field_type
+      when 'number'
+        value.include?('.') ? value.to_f : value.to_i
+      when 'boolean'
+        value == 'true'
+      when 'json'
+        JSON.parse(value) rescue value
+      when 'date'
+        Date.parse(value) rescue value
+      when 'datetime'
+        DateTime.parse(value) rescue value
+      when 'multiselect'
+        JSON.parse(value) rescue [value]
+      else
+        value
+      end
+    end
+
+    def field_config
+      component = LatoCms::TemplateManager.find_component(component_id)
+      return nil unless component
+      component.dig('fields', field_id)
+    end
+
+    def field_type
+      field_config&.dig('type') || 'string'
+    end
+
+    def field_name
+      field_config&.dig('name') || field_id.to_s.humanize
+    end
+
+    def field_required?
+      field_config&.dig('required') == true
+    end
+
+    def field_settings
+      field_config&.dig('settings') || {}
+    end
+
+    def as_json(_options = {})
+      result = {
+        id: id,
+        field_id: field_id,
+        field_type: field_type,
+        field_name: field_name,
+        required: field_required?,
+        value: nil,
+        attachments: []
+      }
+
+      case field_type
+      when 'file', 'image'
+        attached = files.first
+        result[:attachments] = attached ? [attachment_as_json(attached)] : []
+      when 'gallery'
+        order = value ? (JSON.parse(value) rescue []) : []
+        all_files = files.to_a
+        ordered = order.any? ? all_files.sort_by { |f| order.index(f.id.to_s) || Float::INFINITY } : all_files
+        result[:attachments] = ordered.map { |f| attachment_as_json(f) }
+      else
+        result[:value] = parsed_value
+      end
+
+      result
+    end
+
+    private
+
+    def attachment_as_json(attachment)
+      {
+        id: attachment.id,
+        filename: attachment.filename.to_s,
+        content_type: attachment.content_type,
+        url: Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+      }
+    end
+
+    def parse_value
+      return if value.blank?
+
+      case field_type
+      when 'json'
+        begin
+          parsed = JSON.parse(value)
+          self.value = parsed.to_json
+        rescue JSON::ParserError
+          errors.add(:value, 'is not valid JSON')
+          throw :abort
+        end
+      when 'boolean'
+        self.value = ActiveModel::Type::Boolean.new.cast(value).to_s
+      end
+    end
+  end
+end

data/app/models/lato_cms/template_manager.rb

@@ -0,0 +1,64 @@
+module LatoCms
+  class TemplateManager
+    class << self
+      def templates_path
+        Rails.root.join(LatoCms.config.templates_path, 'templates')
+      end
+
+      def components_path
+        Rails.root.join(LatoCms.config.templates_path, 'components')
+      end
+
+      def templates
+        load_yaml_files(templates_path)
+      end
+
+      def components
+        load_yaml_files(components_path)
+      end
+
+      def find_template(template_id)
+        return nil if template_id.blank?
+        templates.find { |t| t['id'] == template_id.to_s }
+      end
+
+      def find_component(component_id)
+        return nil if component_id.blank?
+        components.find { |c| c['id'] == component_id.to_s }
+      end
+
+      def template_options
+        templates.map { |t| [t['name'], t['id']] }
+      end
+
+      def resolve_template_components(template)
+        return [] unless template && template['components']
+
+        template['components'].map do |tc_id, tc_config|
+          component = find_component(tc_config['component_id'])
+          {
+            template_component_id: tc_id.to_s,
+            component_id: tc_config['component_id'].to_s,
+            name: tc_config['name'].presence || component&.dig('name') || tc_config['component_id'].to_s.humanize,
+            required: tc_config['required'] == true,
+            component: component,
+            fields: component ? (component['fields'] || {}) : {}
+          }
+        end
+      end
+
+      private
+
+      def load_yaml_files(path)
+        return [] unless Dir.exist?(path)
+
+        Dir.glob(File.join(path, '*.yml')).filter_map do |file|
+          YAML.load_file(file)
+        rescue Psych::SyntaxError => e
+          Rails.logger.error("LatoCms: Failed to parse YAML file #{file}: #{e.message}")
+          nil
+        end
+      end
+    end
+  end
+end

data/app/views/lato_cms/pages/_component_accordion.html.erb

@@ -0,0 +1,97 @@
+<% accordion_id = "component-#{tc[:template_component_id]}" %>
+<% component_fields = page.fields.select { |f| f.template_component_id == tc[:template_component_id] } %>
+<% required_component = tc[:required] == true %>
+<% enabled_component = page.component_effectively_enabled?(tc[:template_component_id]) %>
+
+<div class="accordion-item">
+  <h2 class="accordion-header" id="heading-<%= accordion_id %>">
+    <button class="accordion-button <%= 'collapsed' unless expanded %>" type="button" data-bs-toggle="collapse" data-bs-target="#collapse-<%= accordion_id %>" aria-expanded="<%= expanded %>" aria-controls="collapse-<%= accordion_id %>">
+      <%= tc[:name] %>
+      <% unless tc[:component] %>
+        <span class="badge bg-warning ms-2"><%= t('lato_cms.fields_component_not_found_badge') %></span>
+      <% end %>
+    </button>
+  </h2>
+  <div id="collapse-<%= accordion_id %>" class="accordion-collapse collapse <%= 'show' if expanded %>" aria-labelledby="heading-<%= accordion_id %>" data-bs-parent="#components-accordion" data-template-component-id="<%= tc[:template_component_id] %>" data-component-id="<%= tc[:component_id] %>">
+    <div class="accordion-body">
+      <% if required_component %>
+        <div>
+      <% else %>
+        <div data-controller="lato-cms-component-toggle"
+             data-lato-cms-component-toggle-active-label-value="<%= t('lato_cms.component_active_label') %>"
+             data-lato-cms-component-toggle-inactive-label-value="<%= t('lato_cms.component_inactive_label') %>"
+             data-lato-cms-component-toggle-saving-label-value="<%= t('lato_cms.component_state_saving') %>"
+             data-lato-cms-component-toggle-saved-label-value="<%= t('lato_cms.component_state_saved') %>"
+             data-lato-cms-component-toggle-error-label-value="<%= t('lato_cms.component_state_save_error') %>">
+
+        <%= form_with url: lato_cms.pages_toggle_component_action_path(page, tc[:template_component_id]), method: :patch,
+            data: { turbo: false, action: 'submit->lato-cms-component-toggle#toggle' } do %>
+        <div class="d-flex justify-content-between align-items-center mb-3 pb-2 border-bottom">
+          <div class="d-flex align-items-center gap-2 small fw-medium <%= enabled_component ? 'text-success' : 'text-muted' %>" data-lato-cms-component-toggle-target="stateWrapper">
+            <i class="<%= enabled_component ? 'bi bi-eye' : 'bi bi-eye-slash' %>" data-lato-cms-component-toggle-target="stateIcon"></i>
+            <span data-lato-cms-component-toggle-target="stateLabel"><%= enabled_component ? t('lato_cms.component_active_label') : t('lato_cms.component_inactive_label') %></span>
+          </div>
+          <div class="d-flex align-items-center gap-2">
+            <span data-lato-cms-component-toggle-target="status"></span>
+            <div class="form-check form-switch m-0">
+            <%= hidden_field_tag :enabled, '0' %>
+            <%= check_box_tag :enabled, '1', enabled_component, class: 'form-check-input', id: "toggle-#{accordion_id}", onchange: 'this.form.requestSubmit()', data: { lato_cms_component_toggle_target: 'checkbox' } %>
+            <%= label_tag "toggle-#{accordion_id}", t('lato_cms.component_enabled_label'), class: 'form-check-label ms-1 small' %>
+            </div>
+          </div>
+        </div>
+        <% end %>
+      <% end %>
+
+      <% if tc[:component] %>
+        <% if required_component %>
+          <div>
+        <% else %>
+          <div data-lato-cms-component-toggle-target="fieldsContainer" class="<%= enabled_component ? '' : 'd-none' %>">
+        <% end %>
+          <%= form_with url: lato_cms.pages_save_fields_action_path(page), method: :post, multipart: true,
+              data: { turbo: false, controller: 'lato-cms-component-form' } do |form| %>
+            <%= hidden_field_tag :template_component_id, tc[:template_component_id] %>
+            <%= hidden_field_tag :component_id, tc[:component_id] %>
+
+            <% tc[:fields].each do |field_id, field_config| %>
+              <% page_field = component_fields.find { |f| f.field_id == field_id } %>
+
+              <div class="mb-3">
+                <%= lato_cms_render_field(
+                    field_id: field_id,
+                    field_config: field_config,
+                    page_field: page_field
+                  ) %>
+              </div>
+            <% end %>
+
+            <div class="d-flex justify-content-end align-items-center gap-3 mt-1">
+              <span data-lato-cms-component-form-target="status"></span>
+              <button type="submit" class="btn btn-sm btn-success" data-lato-cms-component-form-target="submitBtn">
+                <i class="bi bi-check-lg me-1"></i><%= t('lato_cms.fields_save_component') %>
+              </button>
+            </div>
+          <% end %>
+        </div>
+      <% else %>
+        <div class="alert alert-warning mb-0">
+          <i class="bi bi-exclamation-triangle me-1"></i>
+          <%= t('lato_cms.fields_component_missing_alert_html', component_id: tc[:component_id]).html_safe %>
+        </div>
+        <% if component_fields.any? %>
+          <div class="mt-3">
+            <p class="text-muted small mb-2"><%= t('lato_cms.fields_previously_saved_data') %></p>
+            <% component_fields.each do |field| %>
+              <div class="mb-2">
+                <small class="text-muted"><%= field.field_id %>:</small>
+                <span><%= field.value.present? ? field.value.truncate(100) : '-' %></span>
+              </div>
+            <% end %>
+          </div>
+        <% end %>
+      <% end %>
+      </div>
+    </div>
+  </div>
+</div>

data/app/views/lato_cms/pages/_fields_editor.html.erb

@@ -0,0 +1,12 @@
+<% page ||= @page %>
+<% template_components ||= @template_components %>
+
+<div class="accordion" id="components-accordion" data-controller="lato-cms-component-accordion">
+  <% template_components.each_with_index do |tc, index| %>
+    <%= render 'lato_cms/pages/component_accordion',
+        page: page,
+        tc: tc,
+        index: index,
+        expanded: index == 0 %>
+  <% end %>
+</div>

data/app/views/lato_cms/pages/_form_create.html.erb

@@ -0,0 +1,26 @@
+<% page ||= LatoCms::Page.new %>
+
+<%= turbo_frame_tag dom_id(page, 'form') do %>
+  <%= form_with model: page, url: lato_cms.pages_create_action_path, data: { turbo_frame: '_self', controller: 'lato-form' } do |form| %>
+    <%= lato_form_notices class: %w[mb-3] %>
+    <%= lato_form_errors page, class: %w[mb-3] %>
+
+    <div class="mb-3">
+      <%= lato_form_item_label form, :title %>
+      <%= lato_form_item_input_text form, :title, required: true %>
+    </div>
+
+    <% if LatoCms.config.locales.length > 1 %>
+      <div class="mb-3">
+        <%= lato_form_item_label form, :locale %>
+        <%= lato_form_item_input_select form, :locale, LatoCms.config.locales.map { |l| [l.to_s.upcase, l.to_s] }, required: true %>
+      </div>
+    <% else %>
+      <%= form.hidden_field :locale, value: LatoCms.config.locales.first.to_s %>
+    <% end %>
+
+    <div class="d-flex justify-content-end">
+      <%= lato_form_submit form, t('lato_cms.page_create_cta'), class: %w[btn-success] %>
+    </div>
+  <% end %>
+<% end %>

data/app/views/lato_cms/pages/_form_update.html.erb

@@ -0,0 +1,39 @@
+<% page ||= LatoCms::Page.new %>
+
+<%= turbo_frame_tag dom_id(page, 'form') do %>
+  <%= form_with model: page, url: lato_cms.pages_update_action_path(page), method: :patch, data: { turbo_frame: '_self', controller: 'lato-form' } do |form| %>
+    <%= lato_form_notices class: %w[mb-3] %>
+    <%= lato_form_errors page, class: %w[mb-3] %>
+
+    <div class="mb-3">
+      <%= lato_form_item_label form, :title %>
+      <%= lato_form_item_input_text form, :title, required: true %>
+    </div>
+
+    <div class="mb-3">
+      <%= lato_form_item_label form, :permalink %>
+      <%= lato_form_item_input_text form, :permalink, required: true %>
+    </div>
+
+    <div class="mb-3">
+      <%= lato_form_item_label form, :frontend_url, t('lato_cms.form_frontend_url') %>
+      <%= lato_form_item_input_text form, :frontend_url %>
+    </div>
+
+    <div class="mb-3">
+      <% template_options = [[t('lato_cms.form_no_template_option'), '']] + LatoCms::TemplateManager.template_options %>
+      <%= lato_form_item_label form, :template_id, t('lato_cms.form_template') %>
+      <%= lato_form_item_input_select form, :template_id, template_options %>
+      <% if page.template_id.present? && !page.template_available? %>
+        <div class="form-text text-danger">
+          <i class="bi bi-exclamation-triangle me-1"></i>
+          <%= t('lato_cms.form_template_unavailable', template_id: page.template_id) %>
+        </div>
+      <% end %>
+    </div>
+
+    <div class="d-flex justify-content-end">
+      <%= lato_form_submit form, t('lato_cms.cta_update'), class: %w[btn-success] %>
+    </div>
+  <% end %>
+<% end %>

data/app/views/lato_cms/pages/create.html.erb

@@ -0,0 +1,13 @@
+<%= lato_page_head t('lato_cms.page_create_title'), [
+  { label: t('lato_cms.pages_index_title'), path: lato_cms.pages_path },
+  { label: t('lato_cms.page_create_title') }
+] %>
+
+<div class="card mb-4">
+  <div class="card-header">
+    <h2 class="fs-4 mb-0"><%= t('lato_cms.page_create_title') %></h2>
+  </div>
+  <div class="card-body">
+    <%= render 'lato_cms/pages/form_create', page: @page %>
+  </div>
+</div>

data/app/views/lato_cms/pages/fields/_boolean.html.erb

@@ -0,0 +1,16 @@
+<% label = field_config['name'] || field_id.humanize %>
+<% current_value = page_field&.value %>
+<% checked = current_value == 'true' %>
+
+<div class="form-check form-switch">
+  <input type="hidden" name="fields[<%= field_id %>][value]" value="false">
+  <input type="checkbox"
+    class="form-check-input"
+    name="fields[<%= field_id %>][value]"
+    id="fields_<%= field_id %>_value"
+    value="true"
+    <%= 'checked' if checked %>>
+  <label class="form-check-label" for="fields_<%= field_id %>_value">
+    <%= label %>
+  </label>
+</div>

data/app/views/lato_cms/pages/fields/_color.html.erb

@@ -0,0 +1,18 @@
+<% label = field_config['name'] || field_id.humanize %>
+<% required = field_config['required'] == true %>
+<% current_value = page_field&.value.presence || '#000000' %>
+
+<label class="form-label" for="fields_<%= field_id %>_value">
+  <%= label %><%= ' *' if required %>
+</label>
+<div class="d-flex align-items-center gap-2" data-controller="lato-cms-color-field">
+  <input type="color"
+    class="form-control form-control-color"
+    name="fields[<%= field_id %>][value]"
+    id="fields_<%= field_id %>_value"
+    value="<%= current_value %>"
+    data-lato-cms-color-field-target="input"
+    data-action="input->lato-cms-color-field#update"
+    <%= 'required' if required %>>
+  <code class="text-muted small" data-lato-cms-color-field-target="hex"><%= current_value.upcase %></code>
+</div>

data/app/views/lato_cms/pages/fields/_date.html.erb

@@ -0,0 +1,16 @@
+<% label = field_config['name'] || field_id.humanize %>
+<% required = field_config['required'] == true %>
+<% settings = field_config['settings'] || {} %>
+<% current_value = page_field&.value || '' %>
+
+<label class="form-label" for="fields_<%= field_id %>_value">
+  <%= label %><%= ' *' if required %>
+</label>
+<input type="date"
+  class="form-control"
+  name="fields[<%= field_id %>][value]"
+  id="fields_<%= field_id %>_value"
+  value="<%= current_value %>"
+  <%= 'required' if required %>
+  <% if settings['min'] %>min="<%= settings['min'] %>"<% end %>
+  <% if settings['max'] %>max="<%= settings['max'] %>"<% end %>>

data/app/views/lato_cms/pages/fields/_datetime.html.erb

@@ -0,0 +1,16 @@
+<% label = field_config['name'] || field_id.humanize %>
+<% required = field_config['required'] == true %>
+<% settings = field_config['settings'] || {} %>
+<% current_value = page_field&.value || '' %>
+
+<label class="form-label" for="fields_<%= field_id %>_value">
+  <%= label %><%= ' *' if required %>
+</label>
+<input type="datetime-local"
+  class="form-control"
+  name="fields[<%= field_id %>][value]"
+  id="fields_<%= field_id %>_value"
+  value="<%= current_value %>"
+  <%= 'required' if required %>
+  <% if settings['min'] %>min="<%= settings['min'] %>"<% end %>
+  <% if settings['max'] %>max="<%= settings['max'] %>"<% end %>>