Subversion Repositories web.creative

<?php namespace ProcessWire;

/**
 * ProcessWire Repeater Inputfield
 *
 * Maintains a collection of fields that are repeated for any number of times.
 *
 * ProcessWire 3.x, Copyright 2016 by Ryan Cramer
 * https://processwire.com
 * 
 * @property int $repeaterMaxItems
 * @property int $repeaterMinItems
 * @property int $repeaterDepth
 * @property bool $accordionMode
 * @property bool $singleMode
 * 
 * @method string renderRepeaterLabel($label, $cnt, Page $page)
 * 
 *
 */

class InputfieldRepeater extends Inputfield implements InputfieldItemList {

  public static function getModuleInfo() {
    return array(
      'title' => __('Repeater', __FILE__), // Module Title
      'summary' => __('Repeats fields from another template. Provides the input for FieldtypeRepeater.', __FILE__), // Module Summary
      'version' => 106,
      'requires' => 'FieldtypeRepeater',
      );
  }

  /**
   * Array of InputfieldWrapper objects indexed by repeater page ID
   *
   */
  protected $wrappers = array();

  /**
   * Array of text labels indexed by repeater page ID
   *
   */
  protected $labels = array();

  /**
   * The page that the repeaters field lives on, set by FieldtypeRepeater::getInputfield
   * 
   * @var Page
   *
   */
  protected $page;

  /**
   * The field this InputfieldRepeater is serving, set by FieldtypeRepeater::getInputfield
   * 
   * @var Field
   *
   */
  protected $field;

  /**
   * Cached form containing the repeaters
   * 
   * @var InputfieldWrapper
   *
   */
  protected $form;

  /**
   * All Inputfield classes (strings) used by the Inputfield
   * 
   * @var array
   * 
   */
  protected $inputfieldClasses = array();

  /**
   * Are we currently in render value mode? (i.e. render values, but not inputs)
   * 
   * @var bool
   * 
   */
  protected $renderValueMode = false;

  /**
   * Number of required empty Inputfields after processing
   * 
   * @var int 
   * 
   */
  protected $numRequiredEmpty = 0;

  /**
   * Set config defaults
   *
   */
  public function __construct() {
    parent::__construct();
    // these are part of the Fieldtype's config, and automatically set from it
    $this->set('repeaterMaxItems', 0);
    $this->set('repeaterMinItems', 0); 
    $this->set('repeaterDepth', 0);
    $this->set('accordionMode', false);
    $this->set('singleMode', false); 
  }

  /**
   * Initialize the repeaters inputfield
   *
   */
  public function init() {
    parent::init();
    if(is_null($this->page)) $this->page = $this->wire('pages')->newNullPage();
    $this->attr('value', $this->wire('pages')->newPageArray()); 
  }

  /**
   * Render the repeater label
   * 
   * @param string $label Default label
   * @param int $cnt Item index (1-based)
   * @param Page $page Repeater item
   * @return string
   *
   */
  public function ___renderRepeaterLabel($label, $cnt, Page $page) {

    // situations where we skip the render of repeater label because it is not needed
    $repeaterEditID = (int) $this->wire('input')->get('repeater_edit');
    if($repeaterEditID && $repeaterEditID == $page->id) {
      // edit of item requested in URL that matches given $page
      return $label;
    } else if(count($_POST) && !$this->wire('config')->ajax) {
      // POST request that is not ajax
      return $label;
    }
    
    $out = '';
    $repeaterTitle = $this->field ? $this->field->get('repeaterTitle') : '';
    
    if($page->id && $repeaterTitle) {
      // custom repeater titles specified
      $hasCnt = stripos($repeaterTitle, '#n') !== false;
      
      // update index numbers?
      if($hasCnt) {
        // replace "#n" with index number of repeater item
        $repeaterTitle = str_replace("#n", "#$cnt", $repeaterTitle);
      }
      
      if(strpos($repeaterTitle, '{') !== false) {
        // formatted {label}
        $out = $page->getMarkup($repeaterTitle);

      } else if(!$hasCnt && $this->wire('sanitizer')->fieldName($repeaterTitle) === $repeaterTitle) {
        // just a single field name
        $value = $page->getFormatted($repeaterTitle);
        if(is_object($value)) {
          if($value instanceof Page) {
            $out = $value->get('title|name');
          } else if($value instanceof PageArray) {
            $out = $value->implode(', ');
          } else {
            $out = (string) $value;
          }
        }
      } else {
        // label, but with no page variables
        $out = $repeaterTitle;
      }
      
      $out = strip_tags(trim($out));
    }
    
    if(!strlen($out)) {
      // fallback to default
      if(!strlen($label)) $label = $this->field->getLabel();
      $out = "$label #" . $cnt;
    }
  
    // note {brackets} surround text that will be visually muted from the JS side
    if(!$page->id) {
      // non-editable new item
      $out .= ' {• ' . $this->_('This item will become editable after you save.') . '}';
    } else if($page->isUnpublished() && $page->hasStatus(Page::statusOn)) {
      // editable new item
      $out .= ' {• ' . $this->_('New') . '}';
    }
  
    $maxlen = 100;
    if(strlen($out) > $maxlen) {
      $out = substr($out, 0, $maxlen);
      $pos = strrpos($out, ' '); 
      if($pos > ($maxlen / 2)) $out = substr($out, 0, $pos);
    }
    
    return $out;
  }

  /**
   * Get the repeater item type (if used)
   * 
   * @param Page $page
   * @return int
   * 
   */
  protected function getRepeaterItemType(Page $page) {
    if($page) {}
    return 1;
  }

  /**
   * Get the name of the repeater item type (if used)
   * 
   * @param Page|int $type
   * @return string
   *
   */
  protected function getRepeaterItemTypeName($type) {
    if($type) {} // ignore
    return '';
  }
  
  /**
   * Preload all assets used by Inputfields of this type
   * 
   * This ensures all required JS/CSS files are loaded in the original/non-ajax request.
   * This should be called only when needed, like if there are 0 items in the repeater 
   * when ajax-add support enabled.
   * 
   * @param array $fieldIDs Optionally specify the IDs of the Field objects you want to limit preload to.
   * 
   */
  protected function preloadInputfieldAssets($fieldIDs = array()) {
    if(empty($fieldIDs)) $fieldIDs = $this->field->get('repeaterFields');
    if(!is_array($fieldIDs)) return;
    foreach($fieldIDs as $fieldID) {
      $field = $this->wire('fields')->get($fieldID);
      if($field) try {
        // the following forces assets to be loaded
        $inputfield = $field->getInputfield($this->page);
        if($inputfield) $inputfield->renderReady(null, false);
      } catch(\Exception $e) {
        $this->warning("Repeater '$this->name' preload '$field': " . $e->getMessage(), Notice::debug);
      }
    }
  }

  /**
   * Get Inputfields for the given repeater item
   * 
   * @param Page $page
   * @return InputfieldWrapper
   * 
   */
  protected function getRepeaterItemInputfields(Page $page) {
    return $page->template->fieldgroup->getPageInputfields($page, "_repeater{$page->id}");
  }
  

  /**
   * Build the form containing the repeaters
   *
   * @param int $itemID Build form for only this item (optional)
   * @param array|null $loadInputsForIDs If array specified, load inputs for the custom page fields into the form for only these page IDs
   * @return InputfieldWrapper
   * @throws WireException if $this->page or $this->field are set incorrectly
   *
   */
  protected function buildForm($itemID = 0, $loadInputsForIDs = null) {

    // if it's already been built, then return the cached version
    if(!is_null($this->form)) return $this->form; 
  
    // if required fields don't exist then exit
    if(!$this->field || !$this->field->type instanceof FieldtypeRepeater) {
      throw new WireException("You must set a 'field' (type Field) property to {$this->className} of FieldtypeRepeater");
    }
    if(!$this->page || !$this->page->id) {
      throw new WireException("You must set a 'page' (type Page) property to {$this->className} with repeater field '$this->name'");
    }

    /** @var InputfieldWrapper $form */
    $form = $this->wire(new InputfieldWrapper());
    $form->name = 'repeater_form_' . $this->name . ($itemID ? "_$itemID" : "");
    
    /** @var PageArray $value */
    $value = $this->attr('value'); 
  
    // get field label in user's language if available
    $label = $this->field->getLabel();
    if(!$label) $label = ucfirst($this->field->name); 

    // remember which repeater items are open (as stored in cookie), when enabled
    $openIDs = array();
    if((int) $this->field->get('rememberOpen')) {
      $this->addClass('InputfieldRepeaterRememberOpen', 'wrapClass');
      $openIDs = $this->wire('input')->cookie('repeaters_open'); 
      if($openIDs) $openIDs = explode('|', trim($openIDs, '|'));
      if(!is_array($openIDs)) $openIDs = array();
    }
    // merge with any open IDs in session
    $_openIDs = $this->wire('session')->getFor($this, 'openIDs');
    if(is_array($_openIDs) && !empty($_openIDs)) {
      $openIDs = array_merge($openIDs, array_values($_openIDs));
    }
    
    $minItems = $this->repeaterMinItems;
  
    // if there are a minimum required number of items, set them up now
    if(!$itemID && $minItems > 0) {
      $notIDs = $value->explode('id');
      while($value->count() < $minItems) {
        $item = $this->getNextReadyPage($notIDs);
        $value->add($item);
        $notIDs[] = $item->id;
      }
    }
    
    $repeaterCollapse = (int) $this->field->get('repeaterCollapse');
    $cnt = 0;
    $numVisible = 0;
    $numOpen = 0;
    $isPost = $this->wire('input')->requestMethod('POST');
    $isSingle = $this->singleMode;
    
    // create field for each repeater iteration 
    foreach($value as $key => $page) {
      if($itemID && $page->id != $itemID) continue;
      
      /** @var RepeaterPage $page */
      $isUnpublished = $page->isUnpublished();
      $isHidden = $page->isHidden();
      $isOn = $page->hasStatus(Page::statusOn);
      $isReadyItem = $isHidden && $isUnpublished;
      $isClone = $page->get('_repeater_clone'); 
      $isOpen = in_array($page->id, $openIDs) || $isClone || $isSingle;
      $isMinItem = $isReadyItem && $minItems && $cnt < $minItems;
      
      if($isOpen && $numOpen > 0 && $this->accordionMode) $isOpen = false;
      
      // get the inputfields for the repeater page
      if(is_null($loadInputsForIDs) || in_array($page->id, $loadInputsForIDs) || $isOpen) {
        $inputfields = $this->getRepeaterItemInputfields($page);
        $isLoaded = true;
      } else {
        $inputfields = $this->wire(new InputfieldWrapper()); // non loaded
        $isLoaded = false;
      }
      $inputfields->set('useDependencies', false);
      $this->wrappers[$page->id] = $inputfields;
    
      if($isSingle) {
        $delete = null;
        $sort = null;
        $depth = null;
      } else {
        // also add a delete checkbox to the repeater page fields
        $delete = $this->wire('modules')->get('InputfieldCheckbox');
        $delete->attr('id+name', "delete_repeater{$page->id}");
        $delete->addClass('InputfieldRepeaterDelete', 'wrapClass');
        $delete->label = $this->_('Delete');
        $delete->attr('value', $page->id);

        $sort = $this->wire('modules')->get('InputfieldHidden');
        $sort->attr('id+name', "sort_repeater{$page->id}");
        $sort->class = 'InputfieldRepeaterSort';
        $sort->label = $this->_('Sort');
        $sort->attr('value', $cnt);

        if($this->repeaterDepth > 0) {
          $depth = $this->wire('modules')->get('InputfieldHidden');
          $depth->attr('id+name', "depth_repeater{$page->id}");
          $depth->class = 'InputfieldRepeaterDepth';
          $depth->label = $this->_('Depth');
          $depthValue = $page->getDepth();
          $depth->attr('value', $depthValue);
          $depth->set('renderValueAsInput', true);
        } else {
          $depth = null;
        }
      }
      
      $loaded = $this->wire('modules')->get('InputfieldHidden');
      $loaded->attr('id+name', "loaded_repeater{$page->id}");
      $loaded->attr('value', $isLoaded ? 1 : 0);
      $loaded->set('renderValueAsInput', true);
      $loaded->class = 'InputfieldRepeaterLoaded';

      $wrap = $this->wire('modules')->get('InputfieldFieldset'); 
      $wrap->addClass('InputfieldRepeaterItem InputfieldNoFocus');
      if(!$isPost) {
        $wrap->entityEncodeLabel = false;
        $wrap->label =
          "<span class='InputfieldRepeaterItemLabel'>" .
          $this->entityEncode($this->renderRepeaterLabel($label, ++$cnt, $page)) .
          "</span>";
      } else {
        $wrap->label = "$label " . (++$cnt);
      }
      $itemType = $this->getRepeaterItemType($page);
      $itemTypeName = $this->getRepeaterItemTypeName($itemType);
      $wrap->name = "repeater_item_{$page->id}";
      $wrap->wrapAttr('data-page', $page->id);
      $wrap->wrapAttr('data-type', $itemType);
      $wrap->wrapAttr('data-typeName', $itemTypeName);
      $wrap->wrapAttr('data-fnsx', "_repeater$page->id");  // fnsx=field name suffix
      //$wrap->wrapAttr('data-editorPage', $this->page->id);
      //$wrap->wrapAttr('data-parentPage', $page->parent->id);
      $wrap->wrapAttr('data-editUrl', $page->editUrl()); // if needed by any Inputfields within like InputfieldFile/InputfieldImage
      $wrap->set('useDependencies', false);
      
      if($isClone) $wrap->addClass('InputfieldRepeaterItemClone');
      if($itemID) $wrap->addClass('InputfieldRepeaterItemRequested');
      
      if($delete && $page->get('_repeater_delete')) {
        // something indicates it should already show delete state in editor
        $delete->attr('checked', 'checked');
        $wrap->addClass('InputfieldRepeaterDeletePending');
        $wrap->addClass('ui-state-error', 'headerClass');
      }
      
      if($isOpen) {
        $wrap->collapsed = Inputfield::collapsedNo;
        $numOpen++;
      } else if($repeaterCollapse == FieldtypeRepeater::collapseExisting && !$page->get('_repeater_new') && !$isHidden) {
        $wrap->collapsed = Inputfield::collapsedYes;
      } else if($repeaterCollapse == FieldtypeRepeater::collapseExisting && $isMinItem) {
        $wrap->collapsed = Inputfield::collapsedYes;
      } else if($repeaterCollapse == FieldtypeRepeater::collapseAll) {
        $wrap->collapsed = Inputfield::collapsedYes;
      }
      
      $hasErrors = count($inputfields->getErrors()) > 0; 
      if($hasErrors) $wrap->icon = 'warning';

      if(!$isSingle) {
        // add a hidden field that will be populated with a positive value for all visible repeater items
        // this is so that processInput can see this item should be a published item
        $f = $this->wire('modules')->get('InputfieldHidden');
        $f->attr('name', "publish_repeater{$page->id}");
        $f->attr('class', 'InputfieldRepeaterPublish');

        if($isReadyItem) {
          // ready item
          $f->attr('value', 0);
        } else if($isUnpublished && !$isOn) {
          // unpublished item
          $f->attr('value', -1);
        } else {
          // published item
          $f->attr('value', 1);
        }

        $wrap->add($f);

        if($isUnpublished) {
          $wrap->addClass('InputfieldRepeaterUnpublished');
          if(!$isOn) $wrap->addClass('InputfieldRepeaterOff');
        }

        $wrap->add($inputfields);
        $wrap->prepend($delete);
        $wrap->prepend($sort);
        if($depth) $wrap->prepend($depth);
        $wrap->prepend($loaded);
      } else {
        $wrap->add($inputfields);
        $wrap->prepend($loaded);
      }
        
      if($isMinItem) {
        // allow this ready item to be added so that minimum is met
        $wrap->addClass('InputfieldRepeaterMinItem');
        $isReadyItem = false;
      }
      
      if(!$isReadyItem) {
        $form->add($wrap);
        $numVisible++;
      }
      
      $this->labels[$page->id] = $wrap->getSetting('label');
      if($itemID) break;
    } 

    if($itemID) {
      // only rendering a single item, ajax mode
      foreach($form->getAll() as $inputfield) {
        $idAttr = $inputfield->attr('id');
        $inputfield->renderReady($form, $this->renderValueMode);
        $jsValue = $this->wire('config')->js($idAttr);
        if(!empty($jsValue)) {
          $inputfield->appendMarkup .= "<script>ProcessWire.config['$idAttr'] = " . json_encode($jsValue) . ';</script>';
        }
      }
    } else if(!$isSingle) {
      // create a new/blank item to be used as a template for any new items added
      /** @var InputfieldWrapper $wrap */
      $wrap = $this->wire('modules')->get('InputfieldFieldset');
      $wrap->label = $this->renderRepeaterLabel($label, ++$cnt, new NullPage());
      $wrap->class = 'InputfieldRepeaterItem InputfieldRepeaterNewItem';
      $wrap->collapsed = Inputfield::collapsedNo;
      $form->add($wrap);
    }

    // max items warning
    if($this->repeaterMaxItems && $numVisible > $this->repeaterMaxItems) {
      $this->prependMarkup .=
      "<p class='ui-state-error-text'>" .
        sprintf($this->_('Warning: only the first %d item(s) will be used.'), $this->repeaterMaxItems) . 
      "</p>";
    }
    
    // cache
    $this->form = $form;

    return $form; 
  }

  /**
   * Get next page ready to be used as new item
   * 
   * @param array $notIDs Page IDs that we won't allow for the new item (because already rendered)
   * @return Page
   * 
   */
  protected function getNextReadyPage(array $notIDs) {
    /** @var FieldtypeRepeater $fieldtype */
    $fieldtype = $this->field->type;
    /** @var PageArray $value */
    $value = $this->attr('value');
    $readyPage = $fieldtype->getNextReadyPage($this->page, $this->field, $value, $notIDs);
    return $readyPage;
  }

  /**
   * Render a new item for ajax after 'add new' link clicked
   * 
   * @param int $cloneItemID
   * @return string
   * 
   */
  public function renderAjaxNewItem($cloneItemID = 0) {

    /** @var PageArray $value */
    $value = $this->attr('value');
    $clonePage = null;
    $readyPage = null;
  
    if($cloneItemID) {
      foreach($value as $item) {
        if($item->id == $cloneItemID) {
          $clonePage = $item;
          break;
        }
      }
    }
    
    if($clonePage && $clonePage->id) {
      /** @var FieldtypeRepeater $fieldtype */
      $fieldtype = $this->field->type;
      $readyPage = $this->wire('pages')->clone($clonePage, null, true,
        array('set' => array(
          'name' => $fieldtype->getUniqueRepeaterPageName() . 'c', // trailing "c" indicates clone
          'sort' => count($value)+1,
          'status' => $clonePage->status | Page::statusUnpublished
          )
        )
      );
      $readyPage->set('_repeater_clone', $clonePage->id); 
    } else if(!$cloneItemID) {
      $notIDs = $this->wire('sanitizer')->intArray(explode(',', trim($this->wire('input')->get('repeater_not'), ',')));
      $readyPage = $this->getNextReadyPage($notIDs);
      $readyPage->removeStatus(Page::statusHidden);
    } 
  
    if($readyPage) {
      // ensure editing page doesn't get saved (just in case) since we're removing all items
      $this->page->addStatus(Page::statusCorrupted);
      $value->add($readyPage);
      return $this->buildForm($readyPage->id)->render();
    } else {
      return '';
    }
  }
  
  /**
   * Render the "add new" repeater label
   * 
   * @return mixed|string
   * @throws WireException
   * 
   */
  protected function renderAddLabel() {
    $addLabel = $this->field->get('repeaterAddLabel');
    if($this->wire('languages'))  {
      $language = $this->wire('user')->language;
      if(!$language->isDefault()) {
        $addLabel = $this->field->get("repeaterAddLabel$language");
      }
    }
    if(!strlen($addLabel)) $addLabel = $this->_('Add New');
    return $addLabel;
  }

  /**
   * Called before render() or renderValue() method by InputfieldWrapper, before Inputfield-specific CSS/JS files added
   *
   * @param Inputfield|InputfieldWrapper|null The parent Inputfield/wrapper that is rendering it or null if no parent.
   * @param bool $renderValueMode Whether renderValueMode will be used.
   * @return bool
   *
   */
  public function renderReady(Inputfield $parent = null, $renderValueMode = false) {
  
    /** @var User $user */
    $user = $this->wire('user');
    
    $this->wire('modules')->get('JqueryCore')->use('cookie');
    $this->wire('modules')->get('JqueryUI')->use('vex');
    $this->preloadInputfieldAssets();
    
    $min = (int) $this->repeaterMinItems;
    $max = (int) $this->repeaterMaxItems;
    
    if($this->field->get('repeaterLoading') == FieldtypeRepeater::loadingOff) {
      $this->addClass('InputfieldRepeaterNoAjaxAdd', 'wrapClass');
    }
    if($max > 0) {
      $this->addClass('InputfieldRepeaterMax', 'wrapClass');
    }
    if($min > 0) {
      $this->addClass('InputfieldRepeaterMin', 'wrapClass');
    }
    if($this->singleMode) {
      $this->addClass('InputfieldRepeaterSingle', 'wrapClass');
      
    } else if($this->repeaterDepth > 0) {
      $this->addClass('InputfieldRepeaterDepth', 'wrapClass');
    }
    if($this->accordionMode) {
      $this->addClass('InputfieldRepeaterAccordion', 'wrapClass');
    }
    $this->wrapAttr('data-page', $this->page->id);
    $this->wrapAttr('data-max', (int) $this->repeaterMaxItems);
    $this->wrapAttr('data-min', (int) $this->repeaterMinItems);
    $this->wrapAttr('data-depth', (int) $this->repeaterDepth);

    list($editorUrl, $queryString) = explode('?', $this->page->editUrl());
    
    if(strpos($editorUrl, '/users/edit/') && !$user->isSuperuser() && !$user->hasPermission('user-admin')) {
      // to accommodate repeater in user profile, use main page editor 
      $editorUrl = str_replace('/access/users/edit/', '/page/edit/', $editorUrl); 
    }
    
    if($queryString) {}

    $this->wire('config')->js('InputfieldRepeater', array(
      'editorUrl' => $editorUrl,
      'labels' => array(
        'remove' => $this->_x('Click to delete this item, or double-click to delete all', 'repeater-item-action'),
        'removeAll' => $this->_x('Delete all items?', 'repeater-item-action'),
        'toggle' => $this->_x('Click to turn item on/off, or double-click to open/collapse all items', 'repeater-item-action'),
        'clone' => $this->_x('Clone this item?', 'repeater-item-action'),
        'settings' => $this->_x('Show settings?', 'repeater-item-action'),
        'openAll' => $this->_x('Open all items?', 'repeater-item-action'), 
        'collapseAll' => $this->_x('Collapse all items?', 'repeater-item-action'),
        'disabledMinMax' => $this->_('This action is disabled per min and/or max item settings.')
      )
    ));

    return parent::renderReady($parent, $renderValueMode);
  }

  /**
   * Render the footer of the repeater items, which is the "add new" item section
   *
   * @param string $noAjaxAdd Value is '1' if AJAX-adding is disallowed, or blank if it's allowed
   * @return string
   *
   */
  protected function renderFooter($noAjaxAdd) {
    // a hidden checkbox with link that we use to identify when items have been added
    if($this->singleMode) return '';
    $out =
      "<p class='InputfieldRepeaterAddItem'>" .
        "<input class='InputfieldRepeaterAddItemsQty' type='text' name='_{$this->name}_add_items' value='0' />" . // for noAjaxAdd
        "<a href='#' data-type='1' class='InputfieldRepeaterAddLink' data-noajax='$noAjaxAdd'>" .
          "<i class='fa fa-fw fa-plus-circle InputfieldRepeaterSpinner' " .
            "data-on='fa-spin fa-spinner' data-off='fa-plus-circle'></i>" .
          $this->renderAddLabel() .
        "</a>" .
      "</p>";
    return $out;
  }

  /**
   * Render the repeater items
   * 
   * @return string
   *
   */
  public function ___render() {
  
    $input = $this->wire('input');
    $noAjaxAdd = $this->field->get('repeaterLoading') == FieldtypeRepeater::loadingOff ? '1' : '';
    $ajax = $this->wire('config')->ajax;
  
    if($ajax && $input->get('field') == $this->attr('name')) {
      $repeaterAdd = $input->get('repeater_add');
      $repeaterEdit = (int) $input->get('repeater_edit');
      $repeaterClone = (int) $input->get('repeater_clone');
      if($input->get('inrvm')) $this->renderValueMode = true; 
      if($repeaterClone) {
        return $this->renderValueMode ? '' : $this->renderAjaxNewItem($repeaterClone);
      } else if($repeaterAdd !== null && !$noAjaxAdd) {
        return $this->renderValueMode ? '' : $this->renderAjaxNewItem();
      } else if($repeaterEdit) {
        if($this->renderValueMode) {
          return $this->buildForm($repeaterEdit)->renderValue(); 
        } else {
          return $this->buildForm($repeaterEdit)->render();
        }
      }
    }
  
    $out = $this->renderValueMode ? '' : $this->renderFooter($noAjaxAdd);

    $loading = $this->field->get('repeaterLoading');
    $collapse = $this->field->get('repeaterCollapse');
    $forIDs = null; 
    if($loading == FieldtypeRepeater::loadingAll && $collapse != FieldtypeRepeater::collapseNone) $forIDs = array();
    
    $form = $this->buildForm(0, $forIDs);
    $out = ($this->renderValueMode ? $form->renderValue() : $form->render()) . $out;
    
    return $out;
  }

  /**
   * Render value (no inputs)
   * 
   * @return string
   * 
   */
  public function ___renderValue() {
    $flags = $this->getSetting('renderValueFlags');
    if($flags & Inputfield::renderValueMinimal) {
      $out = parent::___renderValue();
    } else {
      $this->renderValueMode = true;
      $out = $this->render();
      $this->renderValueMode = false;
    }
    return $out; 
  }

  /**
   * Process the input from a submitted repeaters field
   * 
   * @param WireInputData $input
   * @return $this
   *
   */
  public function ___processInput(WireInputData $input) {
    
    $isSingle = $this->singleMode; 
    
    /** @var PageArray $value */
    $value = $this->attr('value');
    $loadedIDs = array();
  
    // determine which repeater pages have data posted in this request
    foreach($value as $key => $page) {
      $loadedName = "loaded_repeater$page->id";
      if($isSingle || ((int) $input->$loadedName) > 0) $loadedIDs[$page->id] = $page->id;
    }
  
    $this->buildForm(0, $loadedIDs);
    
    $numChanges = 0;
    $sortChanged = false;
    $value->setTrackChanges(true);
    $pageIDs = array();
    $_openIDs = $this->wire('session')->getFor($this, 'openIDs');
    if(!is_array($_openIDs)) $_openIDs = array();
    $openIDs = $_openIDs; // these two are compared with each other at the end
    $this->numRequiredEmpty = 0;
    $this->getErrors(true); 

    // existing items
    foreach($value as $key => $page) {
      
      /** @var RepeaterPage $page */
      $pageIDs[] = $page->id;
      
      $isHidden = $page->isHidden();
      $isUnpublished = $page->isUnpublished();
      $isOn = $page->hasStatus(Page::statusOn);

      if($isSingle) {
        $publishName = '';
      } else {
        $deleteName = "delete_repeater{$page->id}";
        $sortName = "sort_repeater{$page->id}";
        $publishName = "publish_repeater{$page->id}";
        $depthName = "depth_repeater{$page->id}";

        if($input->$deleteName == $page->id) {
          // @todo add check to Fieldgroups::isFieldNotRemoveable() before attempting remove
          $value->remove($page);
          $numChanges++;
          continue;
        }

        $sort = $input->$sortName;
        // skip pages that don't appear in the POST data (most likely ready pages)
        if(is_null($sort)) continue;

        $page->sort = (int) $sort;
        if($page->isChanged('sort')) {
          // $this->message("Sort changed for field {$this->field} page {$page->id}", Notice::debug); 
          $sortChanged = true;
        }

        if($this->repeaterDepth > 0) {
          $depth = (int) $input->$depthName;
          if($page->getDepth() != $depth) {
            $page->setDepth($depth);
            $numChanges++;
          }
        }
      }
      
      /** @var InputfieldWrapper $wrapper */
      $wrapper = $this->wrappers[$page->id]; 
      $wrapper->resetTrackChanges(true); 
      $wrapper->getErrors(true); // clear out any errors
      $wrapper->processInput($input);
      
      $numErrors = count($wrapper->getErrors());
      $numRequiredEmpty = count($wrapper->getEmpty(true));
      $page->setQuietly('_repeater_errors', $numErrors); // signal to FieldtypeRepeater::savePageField() that page has errors
      $page->setQuietly('_repeater_processed', true); // signal to FieldtypeRepeater::savePageField() that page had input processed
      $this->formToPage($wrapper, $page);
      $publish = $isSingle ? 0 : $input->$publishName;
      
      if($publish !== null) {
        $publish = (int) $publish;
        if($publish > 0 && ($isHidden || $isUnpublished)) {
          // publish requested (publish=1)
          if($isHidden) $page->removeStatus(Page::statusHidden);
          if(!$numErrors && $isUnpublished) $page->removeStatus(Page::statusUnpublished);
          if(!$isOn) $page->addStatus(Page::statusOn);

        } else if($publish < 0) {
          // unpublish requested (publish=-1)
          if($isOn) $page->removeStatus(Page::statusOn);
          if($isHidden) $page->removeStatus(Page::statusHidden);
          if(!$isUnpublished) $page->addStatus(Page::statusUnpublished);

        } else if(!$isOn) {
          // no publish change requested, just ensure page is on
          $page->addStatus(Page::statusOn);
        }
      }
      
      if($numErrors || $numRequiredEmpty) {
        $this->error(sprintf($this->_('Errors in “%s” item %d'), $this->label, $key + 1));
        if(!$page->hasStatus(Page::statusUnpublished)) $this->numRequiredEmpty += $numRequiredEmpty;
        $openIDs[$page->id] = $page->id; // force item with error to be open on next request
      } else if(isset($openIDs[$page->id])) {
        unset($openIDs[$page->id]);
      }

      if($page->isChanged() && $this->page->id) $numChanges++;
    }

    // if the sort changed, then tell the PageArray to sort by _repeater_sort
    if($sortChanged) { 
      $this->value->sort('sort'); 
      $numChanges++;
    }

    if(!$isSingle && $this->field->get('repeaterLoading') == FieldtypeRepeater::loadingOff) { 
      $numNewItems = (int) $input["_{$this->name}_add_items"];
      if($numNewItems) {
        // iterate through each new item added for non-ajax mode
        for($n = 0; $n < $numNewItems; $n++) {
          $page = $this->getNextReadyPage($pageIDs);
          $page->removeStatus(Page::statusHidden);
          $page->sort = count($value)+1;
          $value->add($page);
          $numChanges++;
        }
      }
    }
    
    // if changes occurred, then tell $this->page and the PageArray $value
    if($numChanges) {
      $this->page->trackChange($this->attr('name'));
      $this->trackChange('value');
    }
  
    // if openIDs value changed, update the session variable
    if($_openIDs !== $openIDs) $this->wire('session')->setFor($this, 'openIDs', $openIDs); 

    return $this; 
  }

  /**
   * Take a form (InputfieldWrapper) and map the data to a Page that has the same fields
   *
   * @todo potentially convert this to it's own FormToPage class to avoid duplication between this as ProcessPageEdit
   * 
   * @param InputfieldWrapper $wrapper
   * @param Page $page
   * @param int $level
   *
   */
  protected function formToPage(InputfieldWrapper $wrapper, Page $page, $level = 0) {

    $languages = $this->wire('languages'); 

    foreach($wrapper as $inputfield) {

      $name = $inputfield->attr('name');
      $name = preg_replace('/_repeater\d+$/', '', $name); 

      if($name && $inputfield->isChanged()) {
        if($languages && $inputfield->getSetting('useLanguages')) {
          $value = $page->get($name); 
          if(is_object($value)) {
            $value->setFromInputfield($inputfield); 
            $page->set($name, $value); 
          }
        } else { 
          $value = $inputfield->attr('value'); 
          $page->set($name, $value);
        }

        if($page->isChanged($name)) {
          // if a 'ready' page was changed, then we may now consider it a regular repeater page
          if($page->hasStatus(Page::statusHidden)) $page->removeStatus(Page::statusHidden); 
        }
      }

      if($inputfield instanceof InputfieldWrapper && count($inputfield->getChildren())) {
        $this->formToPage($inputfield, $page, $level + 1); 
      }
    }
  }

  /**
   * Returns whether any values are present
   * 
   * @return bool
   *
   */
  public function isEmpty() {
    /** @var PageArray $value */
    $value = $this->attr('value');
    if(count($value) == 0) return true; 
    $cnt = 0;
    foreach($value as $item) {
      if($item->hasStatus(Page::statusHidden) && $item->hasStatus(Page::statusUnpublished)) continue;
      $cnt++;
    }
    return $cnt === 0; 
  }

  /**
   * Return quantity of published items
   * 
   * @return int
   * 
   */
  public function numPublished() {
    /** @var PageArray $value */
    $value = $this->attr('value');
    if(empty($value) || !count($value)) return 0;
    $num = 0;
    foreach($value as $item) {
      if(!$item->hasStatus(Page::statusUnpublished)) $num++;
    }
    return $num;
  }

  /**
   * Get number of required but empty Inputfields (across all repeater items)
   * 
   * @return int
   * 
   */
  public function numRequiredEmpty() {
    return $this->numRequiredEmpty;
  }

  /**
   * Override the default set() to capture the required $page variable that the repeaters field lives on.
   * 
   * @param string $key
   * @param mixed $value
   * @return Inputfield|InputfieldRepeater
   *
   */
  public function set($key, $value) {
    if($key == 'page') $this->page = $value;
      else if($key == 'field') $this->field = $value; 
      else return parent::set($key, $value);
    return $this;
  }

  /**
   * Set attribute
   * 
   * @param array|string $key
   * @param array|int|string $value
   * @return InputfieldRepeater|Inputfield
   * 
   */
  public function setAttribute($key, $value) {
    if($key === 'value' && $value instanceof Page) {
      if($this->field && method_exists($this->field->type, 'getRepeaterPageArray')) {
        if(!$value->id) $value = null;
        $value = $this->field->type->getRepeaterPageArray($this->page, $this->field, $value); 
      }
    }
    return parent::setAttribute($key, $value); 
  }

  /**
   * Get the repeater wrappers (InputfieldWrappers) indexed by repeater page ID
   * 
   * @param mixed|null Optionally specify key to retrieve just one
   * @return array|InputfieldWrapper
   * 
   */
  public function getWrappers($key = null) {
    if(!is_null($key)) {
      return isset($this->wrappers[$key]) ? $this->wrappers[$key] : null;
    }
    return $this->wrappers;
  }

  /**
   * @return InputfieldWrapper
   * 
   */
  public function ___getConfigInputfields() {
    $inputfields = parent::___getConfigInputfields();
    return $inputfields;
  }

}