lato_cms 3.0.0 → 3.0.2

data/app/controllers/lato_cms/pages_controller.rb

@@ -77,62 +77,20 @@ module LatoCms
         return
       end
 
-      fields_data.each do |field_id, field_data|
-        field = @page.fields.find_or_initialize_by(
-          template_id: @page.template_id,
-          template_component_id: template_component_id,
-          component_id: component_id,
-          field_id: field_id
-        )
-
-        field_config = component&.dig('fields', field_id)
-        field_type = field_config&.dig('type') || 'string'
-
-        case field_type
-        when 'file', 'image'
-          field.save if field.new_record?
-          if field_data[:files].present?
-            Array(field_data[:files]).compact.each { |f| field.files.attach(f) }
-          end
-          if field_data[:remove_file_ids].present?
-            Array(field_data[:remove_file_ids]).reject(&:blank?).each do |file_id_to_remove|
-              field.files.find { |f| f.id == file_id_to_remove.to_i }&.purge
-            end
-          end
-        when 'gallery'
-          field.save if field.new_record?
-          if field_data[:files].present?
-            Array(field_data[:files]).compact.each { |f| field.files.attach(f) }
-          end
-          if field_data[:remove_file_ids].present?
-            Array(field_data[:remove_file_ids]).reject(&:blank?).each do |file_id_to_remove|
-              field.files.find { |f| f.id == file_id_to_remove.to_i }&.purge
-            end
-          end
-          # Persist order: existing IDs in dragged order + any new file IDs appended at end
-          order = Array(field_data[:order]).reject(&:blank?).map(&:to_s)
-          all_ids = field.files.reload.map { |f| f.id.to_s }
-          sorted = order.select { |id| all_ids.include?(id) }
-          new_ids = all_ids - sorted
-          field.value = (sorted + new_ids).to_json
-        when 'multiselect'
-          value = field_data[:value]
-          value = Array(value).reject(&:blank?)
-          field.value = value.to_json
-        else
-          raw_value = field_data.is_a?(ActionController::Parameters) ? field_data[:value] : field_data
-          field.value = raw_value.to_s.presence
-        end
+      template_component = @page.template_components.find { |tc| tc[:template_component_id] == template_component_id.to_s }
 
-        unless field.save
-          errors << { field_id: field_id, errors: field.errors.full_messages }
+      if template_component&.dig(:repeater)
+        save_repeater_fields(template_component, component, params[:repeater_items] || {}, params[:repeater_order] || [], errors)
+      else
+        fields_data.each do |field_id, field_data|
+          save_field(component, template_component_id, component_id, field_id, field_id, field_data, errors)
         end
       end
 
       respond_to do |format|
         if errors.empty?
           format.html { redirect_to lato_cms.pages_show_path(@page), notice: t('lato_cms.fields_saved') }
-          format.json { render json: { message: t('lato_cms.fields_saved') } }
+          format.json { render json: { message: t('lato_cms.fields_saved'), fields: @page.fields.reload.map(&:as_json) } }
         else
           error_messages = errors.map { |e| "#{e[:field_id]}: #{e[:errors].join(', ')}" }.join('; ')
           format.html { redirect_to lato_cms.pages_show_path(@page), alert: error_messages }
@@ -183,6 +141,119 @@ module LatoCms
 
     private
 
+    def save_repeater_fields(template_component, component, repeater_items, repeater_order, errors)
+      template_component_id = template_component[:template_component_id]
+      component_id = template_component[:component_id]
+      item_ids = Array(repeater_order).reject(&:blank?).map(&:to_s)
+
+      order_field = @page.fields.find_or_initialize_by(
+        template_id: @page.template_id,
+        template_component_id: template_component_id,
+        component_id: component_id,
+        field_id: LatoCms::PageField::REPEATER_ORDER_FIELD_ID
+      )
+      order_field.value = item_ids.to_json
+      errors << { field_id: order_field.field_id, errors: order_field.errors.full_messages } unless order_field.save
+
+      existing_item_ids = @page.fields.where(template_component_id: template_component_id).reject(&:repeater_order?).filter_map(&:repeater_item_id).uniq
+      removed_item_ids = existing_item_ids - item_ids
+      removed_item_ids.each do |item_id|
+        @page.fields
+          .where(template_component_id: template_component_id)
+          .where("field_id LIKE ?", "#{ActiveRecord::Base.sanitize_sql_like(item_id)}.%")
+          .destroy_all
+      end
+
+      item_ids.each do |item_id|
+        item_fields = repeater_items[item_id] || repeater_items[item_id.to_sym] || {}
+        (template_component[:fields] || {}).each_key do |field_id|
+          field_data = item_fields[field_id] || item_fields[field_id.to_sym] || {}
+          save_field(component, template_component_id, component_id, field_id, "#{item_id}.#{field_id}", field_data, errors)
+        end
+      end
+    end
+
+    def save_field(component, template_component_id, component_id, config_field_id, persisted_field_id, field_data, errors)
+      field = @page.fields.find_or_initialize_by(
+        template_id: @page.template_id,
+        template_component_id: template_component_id,
+        component_id: component_id,
+        field_id: persisted_field_id
+      )
+
+      field_config = component&.dig('fields', config_field_id)
+      field_type = field_config&.dig('type') || 'string'
+
+      assign_field_value(field, field_type, field_data)
+
+      unless field.save
+        errors << { field_id: persisted_field_id, errors: field.errors.full_messages }
+      end
+    end
+
+    def assign_field_value(field, field_type, field_data)
+      case field_type
+      when 'file'
+        field.save if field.new_record?
+        assign_file_field_files(field, field_data)
+      when 'image'
+        field.save if field.new_record?
+        replace_field_image(field, field_data)
+      when 'gallery'
+        field.save if field.new_record?
+        attach_field_files(field, field_data)
+        remove_field_files(field, field_data)
+        order = Array(field_data[:order]).reject(&:blank?).map(&:to_s)
+        all_ids = field.files.reload.map { |f| f.id.to_s }
+        sorted = order.select { |id| all_ids.include?(id) }
+        field.value = (sorted + (all_ids - sorted)).to_json
+      when 'multiselect'
+        field.value = Array(field_data[:value]).reject(&:blank?).to_json
+      else
+        raw_value = field_data.is_a?(ActionController::Parameters) ? field_data[:value] : field_data
+        field.value = raw_value.to_s.presence
+      end
+    end
+
+    def attach_field_files(field, field_data)
+      return unless field_data[:files].present?
+
+      Array(field_data[:files]).compact.each { |file| field.files.attach(file) }
+    end
+
+    def assign_file_field_files(field, field_data)
+      if field.field_settings['multiple'] != true && field_data[:files].present?
+        new_file = Array(field_data[:files]).compact.first
+        return unless new_file
+
+        field.files.each(&:purge)
+        field.files.attach(new_file)
+      else
+        attach_field_files(field, field_data)
+        remove_field_files(field, field_data)
+      end
+    end
+
+    def remove_field_files(field, field_data)
+      return unless field_data[:remove_file_ids].present?
+
+      Array(field_data[:remove_file_ids]).reject(&:blank?).each do |file_id_to_remove|
+        field.files.find { |file| file.id == file_id_to_remove.to_i }&.purge
+      end
+    end
+
+    def replace_field_image(field, field_data)
+      if field_data[:files].present?
+        new_file = Array(field_data[:files]).compact.first
+        return unless new_file
+
+        field.files.each(&:purge)
+        field.files.attach(new_file)
+      else
+        remove_field_files(field, field_data)
+      end
+    end
+
     def create_params
       params.require(:page).permit(:title, :locale)
     end

data/app/helpers/lato_cms/pages_helper.rb

@@ -42,17 +42,30 @@ module LatoCms
       end
     end
 
-    def lato_cms_render_field(field_id:, field_config:, page_field:)
+    def lato_cms_render_field(field_id:, field_config:, page_field:, input_name_prefix: nil, dom_id_prefix: nil)
       render resolve_lato_cms_field_partial(field_config),
         field_id: field_id,
         field_config: field_config,
-        page_field: page_field
+        page_field: page_field,
+        input_name_prefix: input_name_prefix,
+        dom_id_prefix: dom_id_prefix
     rescue ActionView::MissingTemplate => e
       content_tag(:div, class: 'alert alert-danger mb-0') do
         "Field '#{field_id}' render error: #{e.message}"
       end
     end
 
+    def lato_cms_field_input_name(field_id, suffix = 'value', input_name_prefix: nil, multiple: false)
+      base = input_name_prefix.presence || "fields[#{field_id}]"
+      name = "#{base}[#{suffix}]"
+      multiple ? "#{name}[]" : name
+    end
+
+    def lato_cms_field_dom_id(field_id, suffix = 'value', dom_id_prefix: nil)
+      base = dom_id_prefix.presence || "fields_#{field_id}"
+      "#{base}_#{suffix}".parameterize(separator: '_')
+    end
+
     private
 
     def resolve_lato_cms_field_partial(field_config)

data/app/models/lato_cms/page.rb

@@ -87,14 +87,45 @@ module LatoCms
         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
+          fields: tc[:repeater] ?
+            build_repeater_fields_json(tc, fields_by_component[tc[:template_component_id]] || []) :
+            build_component_fields_json(tc, component_fields)
         }
       end
     end
 
+    def build_component_fields_json(tc, component_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
+
+    def build_repeater_fields_json(tc, component_fields)
+      order = repeater_order(component_fields)
+      fields_by_item = component_fields.reject(&:repeater_order?).group_by(&:repeater_item_id)
+      item_ids = order.presence || fields_by_item.keys.compact
+
+      item_ids.filter_map do |item_id|
+        item_fields = (fields_by_item[item_id] || []).index_by(&:base_field_id)
+        next if item_fields.blank?
+
+        {
+          id: item_id,
+          fields: build_component_fields_json(tc, item_fields)
+        }
+      end
+    end
+
+    def repeater_order(component_fields)
+      order_field = component_fields.find(&:repeater_order?)
+      return [] unless order_field&.value.present?
+
+      JSON.parse(order_field.value)
+    rescue JSON::ParserError
+      []
+    end
+
     def empty_field_json(fid, fconfig)
       {
         id: nil,

data/app/models/lato_cms/page_field.rb

@@ -10,6 +10,8 @@ module LatoCms
     validates :field_id, presence: true
     validates :field_id, uniqueness: { scope: [:page_id, :template_component_id] }
 
+    REPEATER_ORDER_FIELD_ID = "__repeater_order".freeze
+
     before_save :parse_value
 
     def parsed_value
@@ -34,9 +36,27 @@ module LatoCms
     end
 
     def field_config
+      return nil if repeater_order?
+
       component = LatoCms::TemplateManager.find_component(component_id)
       return nil unless component
-      component.dig('fields', field_id)
+      component.dig('fields', base_field_id)
+    end
+
+    def repeater_order?
+      field_id == REPEATER_ORDER_FIELD_ID
+    end
+
+    def repeater_item_id
+      return nil unless field_id.to_s.include?('.')
+
+      field_id.to_s.split('.', 2).first
+    end
+
+    def base_field_id
+      return field_id unless repeater_item_id
+
+      field_id.to_s.split('.', 2).last
     end
 
     def field_type
@@ -58,7 +78,8 @@ module LatoCms
     def as_json(_options = {})
       result = {
         id: id,
-        field_id: field_id,
+        persisted_field_id: field_id,
+        field_id: base_field_id,
         field_type: field_type,
         field_name: field_name,
         required: field_required?,
@@ -67,7 +88,9 @@ module LatoCms
       }
 
       case field_type
-      when 'file', 'image'
+      when 'file'
+        result[:attachments] = files.map { |f| attachment_as_json(f) }
+      when 'image'
         attached = files.first
         result[:attachments] = attached ? [attachment_as_json(attached)] : []
       when 'gallery'
@@ -89,6 +112,7 @@ module LatoCms
         id: attachment.id,
         filename: attachment.filename.to_s,
         content_type: attachment.content_type,
+        byte_size: attachment.byte_size,
         url: Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
       }
     end

data/app/models/lato_cms/template_manager.rb

@@ -41,6 +41,8 @@ module LatoCms
             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,
+            repeater: tc_config['repeater'] == true || tc_config['repeatable'] == true,
+            settings: tc_config['settings'] || {},
             component: component,
             fields: component ? (component['fields'] || {}) : {}
           }

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

@@ -54,16 +54,20 @@
             <%= 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 } %>
+            <% if tc[:repeater] %>
+              <%= render 'lato_cms/pages/repeater', tc: tc, component_fields: component_fields %>
+            <% else %>
+              <% 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>
+                <div class="mb-3">
+                  <%= lato_cms_render_field(
+                      field_id: field_id,
+                      field_config: field_config,
+                      page_field: page_field
+                    ) %>
+                </div>
+              <% end %>
             <% end %>
 
             <div class="d-flex justify-content-end align-items-center gap-3 mt-1">

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

@@ -0,0 +1,22 @@
+<% order_field = component_fields.find(&:repeater_order?) %>
+<% saved_order = begin; order_field&.value.present? ? JSON.parse(order_field.value) : []; rescue JSON::ParserError; []; end %>
+<% fields_by_item = component_fields.reject(&:repeater_order?).group_by(&:repeater_item_id) %>
+<% item_ids = (saved_order.presence || fields_by_item.keys.compact) %>
+<% item_ids = [SecureRandom.uuid] if item_ids.blank? && tc[:settings]['min'].to_i.positive? %>
+
+<div data-controller="lato-cms-repeater">
+  <div data-lato-cms-repeater-target="items">
+    <% item_ids.each_with_index do |item_id, item_index| %>
+      <% item_fields = (fields_by_item[item_id] || []).index_by(&:base_field_id) %>
+      <%= render 'lato_cms/pages/repeater_item', tc: tc, item_id: item_id, item_index: item_index, item_fields: item_fields %>
+    <% end %>
+  </div>
+
+  <template data-lato-cms-repeater-target="template">
+    <%= render 'lato_cms/pages/repeater_item', tc: tc, item_id: 'NEW_RECORD', item_index: 'NEW_INDEX', item_fields: {} %>
+  </template>
+
+  <button type="button" class="btn btn-sm btn-outline-primary" data-action="lato-cms-repeater#add">
+    <i class="bi bi-plus-lg me-1"></i><%= t('lato_cms.repeater_add_item') %>
+  </button>
+</div>

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

@@ -0,0 +1,28 @@
+<div class="card mb-3" data-lato-cms-repeater-target="item" data-repeater-item-id="<%= item_id %>">
+  <input type="hidden" name="repeater_order[]" value="<%= item_id %>" data-lato-cms-repeater-target="orderInput">
+
+  <div class="card-header d-flex justify-content-between align-items-center py-2">
+    <strong class="small"><%= tc[:name] %> #<span data-lato-cms-repeater-target="position"><%= item_index.to_i + 1 %></span></strong>
+    <button type="button" class="btn btn-sm btn-outline-danger" data-action="lato-cms-repeater#remove">
+      <i class="bi bi-trash me-1"></i><%= t('lato_cms.repeater_remove_item') %>
+    </button>
+  </div>
+
+  <div class="card-body pb-2">
+    <% tc[:fields].each do |field_id, field_config| %>
+      <% page_field = item_fields[field_id.to_s] %>
+      <% input_name_prefix = "repeater_items[#{item_id}][#{field_id}]" %>
+      <% dom_id_prefix = "repeater_items_#{item_id}_#{field_id}" %>
+
+      <div class="mb-3">
+        <%= lato_cms_render_field(
+            field_id: field_id,
+            field_config: field_config,
+            page_field: page_field,
+            input_name_prefix: input_name_prefix,
+            dom_id_prefix: dom_id_prefix
+          ) %>
+      </div>
+    <% end %>
+  </div>
+</div>

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

@@ -1,16 +1,18 @@
 <% label = field_config['name'] || field_id.humanize %>
 <% current_value = page_field&.value %>
 <% checked = current_value == 'true' %>
+<% input_name = lato_cms_field_input_name(field_id, input_name_prefix: local_assigns[:input_name_prefix]) %>
+<% input_id = lato_cms_field_dom_id(field_id, dom_id_prefix: local_assigns[:dom_id_prefix]) %>
 
 <div class="form-check form-switch">
-  <input type="hidden" name="fields[<%= field_id %>][value]" value="false">
+  <input type="hidden" name="<%= input_name %>" value="false">
   <input type="checkbox"
     class="form-check-input"
-    name="fields[<%= field_id %>][value]"
-    id="fields_<%= field_id %>_value"
+    name="<%= input_name %>"
+    id="<%= input_id %>"
     value="true"
     <%= 'checked' if checked %>>
-  <label class="form-check-label" for="fields_<%= field_id %>_value">
+  <label class="form-check-label" for="<%= input_id %>">
     <%= label %>
   </label>
 </div>

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

@@ -1,15 +1,17 @@
 <% label = field_config['name'] || field_id.humanize %>
 <% required = field_config['required'] == true %>
 <% current_value = page_field&.value.presence || '#000000' %>
+<% input_name = lato_cms_field_input_name(field_id, input_name_prefix: local_assigns[:input_name_prefix]) %>
+<% input_id = lato_cms_field_dom_id(field_id, dom_id_prefix: local_assigns[:dom_id_prefix]) %>
 
-<label class="form-label" for="fields_<%= field_id %>_value">
+<label class="form-label" for="<%= input_id %>">
   <%= 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"
+    name="<%= input_name %>"
+    id="<%= input_id %>"
     value="<%= current_value %>"
     data-lato-cms-color-field-target="input"
     data-action="input->lato-cms-color-field#update"

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

@@ -2,14 +2,16 @@
 <% required = field_config['required'] == true %>
 <% settings = field_config['settings'] || {} %>
 <% current_value = page_field&.value || '' %>
+<% input_name = lato_cms_field_input_name(field_id, input_name_prefix: local_assigns[:input_name_prefix]) %>
+<% input_id = lato_cms_field_dom_id(field_id, dom_id_prefix: local_assigns[:dom_id_prefix]) %>
 
-<label class="form-label" for="fields_<%= field_id %>_value">
+<label class="form-label" for="<%= input_id %>">
   <%= label %><%= ' *' if required %>
 </label>
 <input type="date"
   class="form-control"
-  name="fields[<%= field_id %>][value]"
-  id="fields_<%= field_id %>_value"
+  name="<%= input_name %>"
+  id="<%= input_id %>"
   value="<%= current_value %>"
   <%= 'required' if required %>
   <% if settings['min'] %>min="<%= settings['min'] %>"<% end %>

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

@@ -2,14 +2,16 @@
 <% required = field_config['required'] == true %>
 <% settings = field_config['settings'] || {} %>
 <% current_value = page_field&.value || '' %>
+<% input_name = lato_cms_field_input_name(field_id, input_name_prefix: local_assigns[:input_name_prefix]) %>
+<% input_id = lato_cms_field_dom_id(field_id, dom_id_prefix: local_assigns[:dom_id_prefix]) %>
 
-<label class="form-label" for="fields_<%= field_id %>_value">
+<label class="form-label" for="<%= input_id %>">
   <%= label %><%= ' *' if required %>
 </label>
 <input type="datetime-local"
   class="form-control"
-  name="fields[<%= field_id %>][value]"
-  id="fields_<%= field_id %>_value"
+  name="<%= input_name %>"
+  id="<%= input_id %>"
   value="<%= current_value %>"
   <%= 'required' if required %>
   <% if settings['min'] %>min="<%= settings['min'] %>"<% end %>

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

@@ -1,29 +1,54 @@
 <% label = field_config['name'] || field_id.humanize %>
 <% required = field_config['required'] == true %>
 <% settings = field_config['settings'] || {} %>
-<% multiple = settings['multiple'] != false %>
+<% multiple = settings['multiple'] == true %>
 <% accept = settings['accept'] %>
+<% files_input_name = lato_cms_field_input_name(field_id, 'files', input_name_prefix: local_assigns[:input_name_prefix], multiple: true) %>
+<% remove_input_name = lato_cms_field_input_name(field_id, 'remove_file_ids', input_name_prefix: local_assigns[:input_name_prefix], multiple: true) %>
+<% input_id = lato_cms_field_dom_id(field_id, 'files', dom_id_prefix: local_assigns[:dom_id_prefix]) %>
 
 <label class="form-label">
   <%= label %><%= ' *' if required %>
 </label>
 
-<% if page_field&.files&.attached? %>
-  <div class="mb-2">
+<div data-controller="lato-cms-file-field"
+     data-field-id="<%= field_id %>"
+     data-lato-cms-file-field-multiple-value="<%= multiple %>"
+     data-new-badge-label="<%= t('lato_cms.field_file_new_badge') %>"
+     data-remove-label="<%= t('lato_cms.field_file_remove') %>"
+     data-remove-pending-label="<%= t('lato_cms.field_file_remove_pending') %>"
+     data-undo-label="<%= t('lato_cms.field_file_remove_undo') %>">
+  <div class="mb-2" data-lato-cms-file-field-target="list">
+  <% if page_field&.files&.attached? %>
     <% page_field.files.each do |file| %>
-      <div class="form-check mb-1 p-2 ps-4 bg-light rounded">
-        <input type="checkbox" class="form-check-input" name="fields[<%= field_id %>][remove_file_ids][]" value="<%= file.id %>" id="remove_file_<%= file.id %>">
-        <label class="form-check-label small" for="remove_file_<%= file.id %>">
-          <i class="bi bi-paperclip me-1"></i><%= file.blob.filename %> (<%= number_to_human_size(file.blob.byte_size) %>) — <span class="text-danger"><%= t('lato_cms.field_file_remove') %></span>
-        </label>
+      <div class="lato-cms-file-field__item" data-lato-cms-file-field-target="item" data-attachment-id="<%= file.id %>">
+        <div class="lato-cms-file-field__info">
+          <i class="bi bi-paperclip"></i>
+          <span><%= file.blob.filename %></span>
+          <span class="text-muted small">(<%= number_to_human_size(file.blob.byte_size) %>)</span>
+        </div>
+        <button type="button" class="btn btn-sm btn-outline-danger" data-action="lato-cms-file-field#remove">
+          <i class="bi bi-trash me-1"></i><%= t('lato_cms.field_file_remove') %>
+        </button>
+        <div class="lato-cms-file-field__removed d-none" data-lato-cms-file-field-target="removedNotice">
+          <span class="text-danger small">
+            <i class="bi bi-trash me-1"></i><%= t('lato_cms.field_file_remove_pending') %>
+          </span>
+          <button type="button" class="btn btn-link btn-sm p-0" data-action="lato-cms-file-field#undo">
+            <%= t('lato_cms.field_file_remove_undo') %>
+          </button>
+        </div>
       </div>
     <% end %>
+  <% end %>
   </div>
-<% end %>
 
-<input type="file"
-  class="form-control"
-  name="fields[<%= field_id %>][files][]"
-  id="fields_<%= field_id %>_files"
-  <%= 'multiple' if multiple %>
-  <% if accept %>accept="<%= accept %>"<% end %>>
+  <input type="file"
+    class="form-control"
+    name="<%= files_input_name %>"
+    id="<%= input_id %>"
+    data-lato-cms-file-field-target="input"
+    data-action="change->lato-cms-file-field#addFiles"
+    <%= 'multiple' if multiple %>
+    <% if accept %>accept="<%= accept %>"<% end %>>
+</div>

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

@@ -2,6 +2,7 @@
 <% required = field_config['required'] == true %>
 <% settings = field_config['settings'] || {} %>
 <% accept = settings['accept'] || 'image/*' %>
+<% files_input_name = lato_cms_field_input_name(field_id, 'files', input_name_prefix: local_assigns[:input_name_prefix], multiple: true) %>
 
 <%# Build ordered file list from value JSON or default order %>
 <% ordered_files = begin
@@ -19,7 +20,7 @@ end %>
   <%= label %><%= ' *' if required %>
 </label>
 
-<div data-controller="lato-cms-gallery-field" data-lato-cms-gallery-field-field-id-value="<%= field_id %>">
+<div data-controller="lato-cms-gallery-field" data-lato-cms-gallery-field-field-id-value="<%= field_id %>" data-lato-cms-gallery-field-input-name-prefix-value="<%= local_assigns[:input_name_prefix].presence || "fields[#{field_id}]" %>">
   <div class="lato-cms-gallery-field__grid mb-2"
        data-lato-cms-gallery-field-target="grid"
        data-action="dragover->lato-cms-gallery-field#onGridDragOver drop->lato-cms-gallery-field#onGridDrop">
@@ -45,7 +46,7 @@ end %>
     <i class="bi bi-plus-lg me-1"></i><%= t('lato_cms.field_gallery_add_images') %>
     <input type="file"
       class="d-none"
-      name="fields[<%= field_id %>][files][]"
+      name="<%= files_input_name %>"
       accept="<%= accept %>"
       multiple
       data-lato-cms-gallery-field-target="fileInput"