true);
/**
* Initialize the field type
*/
public function initialize() {
$this->name = 'enhanced_repeater';
$this->label = __('Enhanced Repeater', 'advanced-gallery-repeater-fields-for-acf');
$this->category = 'layout';
$this->description = __('Add rows of repeating fields. Works with ACF Free!', 'advanced-gallery-repeater-fields-for-acf');
// Localization
$this->l10n = array(
'min' => __('Minimum rows reached ({min} rows)', 'advanced-gallery-repeater-fields-for-acf'),
'max' => __('Maximum rows reached ({max} rows)', 'advanced-gallery-repeater-fields-for-acf'),
);
// Default field values
$this->defaults = array(
'sub_fields' => array(),
'min' => 0,
'max' => 0,
'layout' => 'table',
'button_label' => __('Add Row', 'advanced-gallery-repeater-fields-for-acf'),
);
// Register revision field filters to handle repeater data in post revisions
add_filter('_wp_post_revision_fields', array($this, 'register_revision_field_filters'), 20, 2);
// ACF only flattens/nests sub-fields for the container types it ships
// with - these filters are registered per field type. Without them our
// sub-fields are silently dropped by acf_add_local_field_group(), local
// JSON sync, and Tools > Export/Import.
$this->add_field_filter('acf/prepare_field_for_export', array($this, 'prepare_field_for_export'));
$this->add_field_filter('acf/prepare_field_for_import', array($this, 'prepare_field_for_import'));
}
/**
* Keep sub-fields nested when the field group is exported
*
* @param array $field The field settings.
* @return array
*/
public function prepare_field_for_export($field) {
if (!empty($field['sub_fields'])) {
$field['sub_fields'] = acf_prepare_fields_for_export($field['sub_fields']);
}
return $field;
}
/**
* Flatten sub-fields into siblings when the field group is imported
*
* ACF stores sub-fields as separate field records pointing back at the
* parent, so the importer expects [field, sub_1, sub_2, ...].
*
* @param array $field The field settings.
* @return array
*/
public function prepare_field_for_import($field) {
if (empty($field['sub_fields'])) {
return $field;
}
$sub_fields = acf_extract_var($field, 'sub_fields');
foreach ($sub_fields as $i => $sub_field) {
$sub_fields[$i]['parent'] = $field['key'];
$sub_fields[$i]['menu_order'] = $i;
}
return array_merge(array($field), $sub_fields);
}
/**
* Enqueue scripts for field group admin
* This ensures ACF's field group JavaScript recognizes our field supports sub-fields
*/
public function field_group_admin_enqueue_scripts() {
// Ensure ACF's field group script is loaded
wp_enqueue_script('acf-field-group');
// Tell ACF's JavaScript that this field supports sub-fields
$inline_script = "
(function($) {
if (typeof acf === 'undefined') return;
// Wait for ACF to be fully ready
acf.addAction('ready', function() {
// Register field type support for sub-fields
if (acf.getFieldType) {
var fieldType = acf.getFieldType('enhanced_repeater');
if (fieldType) {
fieldType.supports = fieldType.supports || {};
fieldType.supports.sub_fields = true;
}
}
// Also add to the field types data if it exists
if (acf.data && acf.data.fieldTypes) {
acf.data.fieldTypes['enhanced_repeater'] = acf.data.fieldTypes['enhanced_repeater'] || {};
acf.data.fieldTypes['enhanced_repeater'].supports = acf.data.fieldTypes['enhanced_repeater'].supports || {};
acf.data.fieldTypes['enhanced_repeater'].supports.sub_fields = true;
}
});
// Ensure sub-fields are included when saving the field group
acf.addFilter('prepare_field_for_save', function(field) {
if (field.type === 'enhanced_repeater') {
// Ensure sub_fields property exists
field.sub_fields = field.sub_fields || [];
}
return field;
});
})(jQuery);
";
wp_add_inline_script('acf-field-group', $inline_script);
}
/**
* Enqueue scripts and styles
* Ensure ACF's repeater functionality is available
*/
public function input_admin_enqueue_scripts() {
// Enqueue ACF's core scripts
wp_enqueue_script('acf-input');
wp_enqueue_style('acf-input');
// Enqueue jQuery UI for drag and drop
wp_enqueue_script('jquery-ui-sortable');
// Enqueue our custom repeater JavaScript
wp_enqueue_script(
'agrfuxd-repeater-field',
AGRFUXD_PLUGIN_URL . 'assets/js/repeater-field.js',
array('jquery', 'jquery-ui-sortable', 'acf-input'),
AGRFUXD_VERSION,
true
);
// Enqueue repeater CSS for styling
wp_enqueue_style(
'agrfuxd-repeater-field',
AGRFUXD_PLUGIN_URL . 'assets/css/repeater-field.css',
array('acf-input'),
AGRFUXD_VERSION
);
}
/**
* Render field settings in ACF admin
* This is the KEY method that shows the Sub Fields UI!
*/
public function render_field_settings($field) {
// Ensure sub_fields is an array
$sub_fields = isset($field['sub_fields']) && is_array($field['sub_fields']) ? $field['sub_fields'] : array();
// Get the parent ID - use ID if available, fall back to key for new fields
$parent = 0;
if (!empty($field['ID'])) {
$parent = $field['ID'];
} elseif (!empty($field['key'])) {
$parent = $field['key'];
}
// Sub Fields section - CRITICAL: This shows the "+ Add Field" UI
$args = array(
'fields' => $sub_fields,
'parent' => $parent,
);
?>
__('Layout', 'advanced-gallery-repeater-fields-for-acf'),
'instructions' => '',
'type' => 'radio',
'name' => 'layout',
'layout' => 'horizontal',
'choices' => array(
'table' => __('Table', 'advanced-gallery-repeater-fields-for-acf'),
'block' => __('Block', 'advanced-gallery-repeater-fields-for-acf'),
'row' => __('Row', 'advanced-gallery-repeater-fields-for-acf'),
),
));
// Minimum Rows
acf_render_field_setting($field, array(
'label' => __('Minimum Rows', 'advanced-gallery-repeater-fields-for-acf'),
'instructions' => '',
'type' => 'number',
'name' => 'min',
'placeholder' => '0',
));
// Maximum Rows
acf_render_field_setting($field, array(
'label' => __('Maximum Rows', 'advanced-gallery-repeater-fields-for-acf'),
'instructions' => '',
'type' => 'number',
'name' => 'max',
'placeholder' => '0',
));
// Button Label
acf_render_field_setting($field, array(
'label' => __('Button Label', 'advanced-gallery-repeater-fields-for-acf'),
'instructions' => '',
'type' => 'text',
'name' => 'button_label',
'placeholder' => __('Add Row', 'advanced-gallery-repeater-fields-for-acf'),
));
}
/**
* Load field configuration (for Field Group editor)
* This ensures sub-fields are loaded when editing the field group
*/
public function load_field($field) {
// Ensure sub_fields is set
if (!isset($field['sub_fields'])) {
$field['sub_fields'] = array();
}
// Load sub-fields if we have a valid field key
if (!empty($field['key'])) {
$sub_fields = acf_get_fields($field);
if (is_array($sub_fields)) {
$field['sub_fields'] = $sub_fields;
}
}
return $field;
}
/**
* Update field configuration (when saving Field Group)
* This ensures sub-fields are properly saved with the parent field
*/
public function update_field($field) {
// Ensure sub_fields array exists
if (!isset($field['sub_fields'])) {
$field['sub_fields'] = array();
}
return $field;
}
/**
* Delete field (when removing from Field Group)
* This cleans up sub-fields when the parent field is deleted
*/
public function delete_field($field) {
// Get sub-fields
if (!empty($field['sub_fields'])) {
foreach ($field['sub_fields'] as $sub_field) {
acf_delete_field($sub_field['ID']);
}
}
}
/**
* Duplicate field (when duplicating in Field Group)
* This properly duplicates sub-fields when the parent field is duplicated
*/
public function duplicate_field($field) {
// Duplicate sub-fields if they exist
if (!empty($field['sub_fields'])) {
$new_sub_fields = array();
foreach ($field['sub_fields'] as $sub_field) {
$new_sub_field = acf_duplicate_field($sub_field['ID'], $field['ID']);
if ($new_sub_field) {
$new_sub_fields[] = $new_sub_field;
}
}
$field['sub_fields'] = $new_sub_fields;
}
return $field;
}
/**
* Prepare field for input
*/
public function prepare_field($field) {
// Ensure field key exists
if (empty($field['key'])) {
return $field;
}
// Ensure sub_fields are loaded
if (empty($field['sub_fields'])) {
$field['sub_fields'] = acf_get_fields($field);
}
// Ensure value is loaded
if (!isset($field['value'])) {
$field['value'] = array();
}
return $field;
}
/**
* Render the field input in admin
*/
public function render_field($field) {
// Get sub fields (let ACF handle loading)
$sub_fields = acf_get_fields($field);
// Check for sub-fields
if (empty($sub_fields)) {
echo '';
esc_html_e('Please add sub-fields to this repeater by clicking "+ Add Field" below this field in the field group editor.', 'advanced-gallery-repeater-fields-for-acf');
echo '
';
return;
}
// Get value
$value = $field['value'];
if (!is_array($value)) {
$value = array();
}
// Apply min rows
if ($field['min'] && count($value) < $field['min']) {
for ($i = count($value); $i < $field['min']; $i++) {
$value[] = array();
}
}
// Setup vars
$layout = $field['layout'];
$button_label = $field['button_label'];
// Wrapper attributes
$div = array(
'class' => 'acf-repeater',
'data-min' => $field['min'],
'data-max' => $field['max'],
);
?>
data-type="repeater">
|
'acf-th',
'data-name' => $sub_field['_name'],
'data-type' => $sub_field['type'],
'data-key' => $sub_field['key'],
);
if ($sub_field['required']) {
$atts['data-required'] = '1';
}
?>
>
|
|
$row) : ?>
render_row($field, $sub_fields, $i, $row); ?>
'acf-row',
'data-id' => $i,
);
if ($field['layout'] === 'row') {
$attrs['class'] .= ' acf-row-layout-row';
} elseif ($field['layout'] === 'block') {
$attrs['class'] .= ' acf-row-layout-block';
}
?>
>
|
|
|
get_sub_fields($field);
if (empty($sub_fields)) {
return $value;
}
$rows = array();
foreach ($value as $row) {
if (!is_array($row)) {
continue;
}
$formatted_row = array();
foreach ($sub_fields as $sub_field) {
$sub_value = $this->extract_sub_value($row, $sub_field);
$name = !empty($sub_field['_name']) ? $sub_field['_name'] : $sub_field['name'];
$formatted_row[$name] = function_exists('acf_format_value')
? acf_format_value($sub_value, $post_id, $sub_field)
: $sub_value;
}
$rows[] = $formatted_row;
}
return $rows;
}
/**
* Get the repeater's sub-fields, tolerating a missing/empty lookup
*
* @param array $field Field array.
* @return array
*/
protected function get_sub_fields($field) {
if (!empty($field['sub_fields']) && is_array($field['sub_fields'])) {
return $field['sub_fields'];
}
$sub_fields = acf_get_fields($field);
return is_array($sub_fields) ? $sub_fields : array();
}
/**
* Pull one sub-field's value out of a stored row
*
* Rows may be keyed by field key (current format), or by field name
* (the format this plugin wrote before 2.1.6, and the format used when a
* developer calls update_field() with plain names).
*
* @param array $row A single stored row.
* @param array $sub_field Sub-field array.
* @return mixed Sub-field value, or null when the row has no value for it.
*/
protected function extract_sub_value($row, $sub_field) {
$candidates = array();
if (!empty($sub_field['key'])) {
$candidates[] = $sub_field['key'];
}
if (!empty($sub_field['_name'])) {
$candidates[] = $sub_field['_name'];
}
if (!empty($sub_field['name'])) {
$candidates[] = $sub_field['name'];
}
foreach ($candidates as $candidate) {
if (array_key_exists($candidate, $row)) {
return $row[$candidate];
}
}
return null;
}
/**
* Validate value
*/
public function validate_value($valid, $value, $field, $input) {
// Check min/max rows
if (!is_array($value)) {
$value = array();
}
$count = count($value);
if ($field['min'] && $count < $field['min']) {
/* translators: %d: minimum number of rows */
$valid = sprintf(__('Minimum rows reached (%d rows)', 'advanced-gallery-repeater-fields-for-acf'), $field['min']);
return $valid;
}
if ($field['max'] && $count > $field['max']) {
/* translators: %d: maximum number of rows */
$valid = sprintf(__('Maximum rows exceeded (%d rows)', 'advanced-gallery-repeater-fields-for-acf'), $field['max']);
return $valid;
}
return $valid;
}
/**
* Update value before saving
*
* Rows are stored keyed by sub-field key, matching ACF's own convention so
* that have_rows() / get_sub_field() can resolve them.
*/
public function update_value($value, $post_id, $field) {
// Return null if empty
if (empty($value) || !is_array($value)) {
return null;
}
$sub_fields = $this->get_sub_fields($field);
$rows = array();
foreach ($value as $row) {
if (!is_array($row)) {
continue;
}
// Re-key the row. Posted rows already arrive keyed by field key,
// but update_field() calls from theme code usually use names.
if (!empty($sub_fields)) {
$normalized_row = array();
foreach ($sub_fields as $sub_field) {
$normalized_row[$sub_field['key']] = $this->extract_sub_value($row, $sub_field);
}
$row = $normalized_row;
}
// Skip completely empty rows (keeps the stored data clean)
$has_value = false;
foreach ($row as $val) {
if (!empty($val) || $val === '0' || $val === 0) {
$has_value = true;
break;
}
}
if ($has_value) {
$rows[] = $row;
}
}
// Array indexes must be 0, 1, 2... for ACF's row loop
return empty($rows) ? null : $rows;
}
/**
* Load value from database
*/
public function load_value($value, $post_id, $field) {
$sub_fields = $this->get_sub_fields($field);
// Native ACF repeater storage: the field's own meta holds the row count
// and each sub value lives in its own "{field}_{row}_{sub}" meta row.
// WP All Import writes this format, so read it as well as our own.
if (is_numeric($value)) {
return $this->load_rows_from_meta(intval($value), $post_id, $field, $sub_fields);
}
// Handle serialized data
if (is_string($value) && !empty($value)) {
$value = maybe_unserialize($value);
}
// Ensure we have an array
if (!is_array($value)) {
return array();
}
if (empty($sub_fields)) {
return $value;
}
// Normalize every row to be keyed by sub-field key. ACF's
// get_sub_field() resolves a row value by key, so rows keyed by field
// name (how this plugin stored them before 2.1.6) silently returned
// nothing inside a have_rows() loop.
$normalized_value = array();
foreach ($value as $row) {
if (!is_array($row)) {
continue;
}
$normalized_row = array();
foreach ($sub_fields as $sub_field) {
$normalized_row[$sub_field['key']] = $this->extract_sub_value($row, $sub_field);
}
$normalized_value[] = $normalized_row;
}
return $normalized_value;
}
/**
* Rebuild rows stored in ACF's native repeater meta layout
*
* @param int $count Number of rows recorded in the field's own meta.
* @param mixed $post_id ACF post ID.
* @param array $field Field array.
* @param array $sub_fields Sub-field arrays.
* @return array
*/
protected function load_rows_from_meta($count, $post_id, $field, $sub_fields) {
$rows = array();
if ($count < 1 || empty($sub_fields) || empty($field['name'])) {
return $rows;
}
for ($i = 0; $i < $count; $i++) {
$row = array();
foreach ($sub_fields as $sub_field) {
$meta_key = $field['name'] . '_' . $i . '_' . $sub_field['name'];
$row[$sub_field['key']] = $this->get_sub_field_meta($post_id, $meta_key);
}
$rows[] = $row;
}
return $rows;
}
/**
* Read a single sub-field meta value
*
* acf_get_metadata() resolves post/user/term/option IDs the same way ACF
* does; get_post_meta() is only a fallback for very old ACF builds.
*
* @param mixed $post_id ACF post ID.
* @param string $meta_key Meta key to read.
* @return mixed
*/
protected function get_sub_field_meta($post_id, $meta_key) {
if (function_exists('acf_get_metadata')) {
return acf_get_metadata($post_id, $meta_key);
}
return get_post_meta($post_id, $meta_key, true);
}
/**
* Register revision field filters for enhanced repeater fields
*
* Hooks into _wp_post_revision_fields to detect enhanced_repeater fields
* and add custom formatting filters before ACF processes them
*/
public function register_revision_field_filters($fields, $post) {
$post_id = is_object($post) ? $post->ID : (is_array($post) ? $post['ID'] : 0);
if (!$post_id) {
return $fields;
}
$meta = get_post_meta($post_id);
foreach ($meta as $name => $value) {
if (strpos($name, '_') === 0) {
continue;
}
$key = isset($meta['_' . $name]) ? $meta['_' . $name][0] : null;
if (!$key) {
continue;
}
$field = acf_get_field($key);
if (!$field || $field['type'] !== 'enhanced_repeater') {
continue;
}
add_filter("_wp_post_revision_field_{$name}", array($this, 'format_repeater_revision_value'), 9, 4);
}
return $fields;
}
/**
* Format repeater revision value for display
*
* Converts nested array data into a readable string format
* to prevent "Array to string conversion" warnings in revision history
*/
public function format_repeater_revision_value($value, $field_name, $post, $direction) {
$raw = maybe_unserialize($value);
if (!is_array($raw)) {
return $value;
}
$label_map = array();
$meta_key = get_post_meta($post->ID, '_' . $field_name, true);
if ($meta_key) {
$field = acf_get_field($meta_key);
if ($field && !empty($field['sub_fields'])) {
foreach ($field['sub_fields'] as $sub) {
$label_map[$sub['name']] = $sub['label'];
$label_map[$sub['key']] = $sub['label'];
}
}
}
$lines = array();
foreach ($raw as $i => $row) {
if (!is_array($row)) {
continue;
}
$cells = array();
foreach ($row as $key => $val) {
if (is_array($val)) {
$val = implode(', ', array_map('strval', $val));
}
$label = isset($label_map[$key]) ? $label_map[$key] : $key;
$cells[] = $label . ': ' . $val;
}
$lines[] = 'Row ' . ($i + 1) . ' [' . implode(' | ', $cells) . ']';
}
return implode("\n", $lines);
}
}