class GeneralLinkFormatter in Formatter Suite 8

Formats a link field as one or more links.

The link field itself includes title text, a URL, and possible URL options. The field may be configured to allow internal, external, or both URL types, and a single value or multiple values.

This formatter supports:

Showing a title:
- Using the link field's title text.
- Using the URL in plain text.
- Using manually entered text.
Adding manually entered classes.
Showing a link:
- Adding selected standard "rel" and "target" options.

The "rel" and "target" options are grouped and presented as menu choices and checkboxes.

Plugin annotation


@FieldFormatter(
  id          = "formatter_suite_general_link",
  label       = @Translation("Formatter Suite - General link"),
  weight      = 1000,
  field_types = {
    "link",
  }
)

Hierarchy

class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
- class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
  - class \Drupal\Core\Field\PluginSettingsBase implements DependentPluginInterface, PluginSettingsInterface
    class \Drupal\Core\Field\FormatterBase implements FormatterInterface, ContainerFactoryPluginInterface
    class \Drupal\formatter_suite\Plugin\Field\FieldFormatter\GeneralLinkFormatter

Expanded class hierarchy of GeneralLinkFormatter

File

src/Plugin/Field/FieldFormatter/GeneralLinkFormatter.php, line 45

Namespace

Drupal\formatter_suite\Plugin\Field\FieldFormatter

View source

class GeneralLinkFormatter extends FormatterBase {

  /*---------------------------------------------------------------------
   *
   * Configuration.
   *
   *---------------------------------------------------------------------*/

  /**
   * Returns an array of title styles, for fields with titles.
   *
   * @return string[]
   *   Returns an associative array with internal names as keys and
   *   human-readable translated names as values.
   */
  protected static function getTitleStyles() {
    return [
      'text_from_link' => t("Use the link field's title"),
      'text_from_url' => t("Use the link field's URL"),
      'text_custom' => t('Use custom text'),
    ];
  }

  /**
   * Returns an array of title styles, for fields without titles.
   *
   * @return string[]
   *   Returns an associative array with internal names as keys and
   *   human-readable translated names as values.
   */
  protected static function getTitleStylesFieldNoTitle() {
    return [
      'text_from_url' => t("Use the link field's URL"),
      'text_custom' => t('Use custom text'),
    ];
  }

  /**
   * Returns an array of choices for how to open a link.
   *
   * @return string[]
   *   Returns an associative array with internal names as keys and
   *   human-readable translated names as values.
   */
  protected static function getOpenLinkInValues() {
    return [
      '_self' => t('Open the linked item in the same tab/window'),
      '_blank' => t('Open the linked item in a new tab/window'),
      'download' => t('Download the linked item'),
    ];
  }

  /**
   * Returns an array of link topic annotation.
   *
   * @return string[]
   *   Returns an associative array with internal names as keys and
   *   human-readable translated names as values.
   */
  protected static function getLinkTopicValues() {
    return [
      'any' => t('- Unspecified -'),
      'alternate' => t('Alternate form of this item'),
      'author' => t('Author information'),
      'bookmark' => t('Bookmarkable permalink'),
      'canonical' => t('Canonical (preferred) form of this item'),
      'help' => t('Help information'),
      'license' => t('License information'),
    ];
  }

  /**
   * Returns an array of list styles.
   *
   * @return string[]
   *   Returns an associative array with internal names as keys and
   *   human-readable translated names as values.
   */
  protected static function getListStyles() {
    return [
      'span' => t('Single line list'),
      'ol' => t('Numbered list'),
      'ul' => t('Bulleted list'),
      'div' => t('Non-bulleted block list'),
    ];
  }

  /**
   * {@inheritdoc}
   */
  public static function defaultSettings() {
    return array_merge([
      'titleStyle' => 'text_from_link',
      'titleCustomText' => '',
      'classes' => '',
      'showLink' => TRUE,
      'openLinkIn' => '_self',
      'noreferrer' => FALSE,
      'noopener' => FALSE,
      'nofollow' => FALSE,
      'linkTopic' => 'any',
      'listStyle' => 'span',
      'listSeparator' => ', ',
    ], parent::defaultSettings());
  }

  /**
   * {@inheritdoc}
   */
  public function settingsSummary() {

    // Sanitize current settings.
    $this
      ->sanitizeSettings();
    $isMultiple = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->isMultiple();

    // Summarize.
    $summary = [];
    switch ($this
      ->getSetting('titleStyle')) {
      case 'text_from_link':
        $summary[] = $this
          ->t('Show field title');
        break;
      case 'text_from_url':
        $summary[] = $this
          ->t('Show field URL');
        break;
      case 'text_custom':
        $summary[] = $this
          ->t('Show custom text');
        break;
    }
    if ($this
      ->getSetting('showLink') === FALSE) {
      $summary[] = $this
        ->t('No link');
    }
    else {
      switch ($this
        ->getSetting('openLinkIn')) {
        case '_self':
          $summary[] = $this
            ->t('Open in current tab/window');
          break;
        case '_blank':
          $summary[] = $this
            ->t('Open in new tab/window');
          break;
        case 'download':
          $summary[] = $this
            ->t('Download');
          break;
      }
      $text = '';
      if ($this
        ->getSetting('noreferrer') === TRUE) {
        $text .= 'noreferrer ';
      }
      if ($this
        ->getSetting('noopener') === TRUE) {
        $text .= 'noopener ';
      }
      if ($this
        ->getSetting('nofollow') === TRUE) {
        $text .= 'nofollow ';
      }
      if (empty($text) === FALSE) {
        $summary[] = $text;
      }
    }

    // If the field can store multiple values, then summarize list style.
    if ($isMultiple === TRUE) {
      $listStyles = $this
        ->getListStyles();
      $listStyle = $this
        ->getSetting('listStyle');
      $listSeparator = $this
        ->getSetting('listSeparator');
      $text = $listStyles[$listStyle];
      if ($listStyle === 'span' && empty($listSeparator) === FALSE) {
        $text .= $this
          ->t(', with separator');
      }
      $summary[] = $text;
    }
    return $summary;
  }

  /*---------------------------------------------------------------------
   *
   * Settings form.
   *
   *---------------------------------------------------------------------*/

  /**
   * Returns a brief description of the formatter.
   *
   * @return string
   *   Returns a brief translated description of the formatter.
   */
  protected function getDescription() {
    $isMultiple = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->isMultiple();
    if ($isMultiple === TRUE) {
      return $this
        ->t("Format field values as links that show the title or URL. Multiple field values are shown as a list on one line, bulleted, numbered, or in blocks.");
    }
    return $this
      ->t("Format a field value as a link that shows a title or URL.");
  }

  /**
   * {@inheritdoc}
   */
  public function settingsForm(array $form, FormStateInterface $formState) {
    $this
      ->sanitizeSettings();

    //
    // Get field settings.
    //
    // - If the link's URL is required to be internal, then below we can omit
    //   form items that are only useful for external links.
    //
    // - If the link has no title, then we can adjust form items to omit using
    //   the link field's title.
    $fieldSettings = $this
      ->getFieldSettings();
    $isMultiple = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->isMultiple();
    $linkIsInternalOnly = FALSE;
    if ($fieldSettings['link_type'] === LinkItemInterface::LINK_INTERNAL) {
      $linkIsInternalOnly = TRUE;
    }
    $linkTitleDisabled = FALSE;
    if ($fieldSettings['title'] === DRUPAL_DISABLED) {
      $linkTitleDisabled = TRUE;
    }

    // Below, some checkboxes and select choices show/hide other form
    // elements. We use Drupal's obscure 'states' feature, which adds
    // Javascript to elements to auto show/hide based upon a set of
    // simple conditions.
    //
    // Those conditions need to reference the form elements to check
    // (e.g. a checkbox), but the element ID and name are automatically
    // generated by the parent form. We cannot set them, or predict them,
    // so we cannot use them. We could use a class, but this form may be
    // shown multiple times on the same page, so a simple class would not be
    // unique. Instead, we create classes for this form only by adding a
    // random number marker to the end of the class name.
    $marker = rand();

    // Add branding.
    $elements = [];
    $elements = Branding::addFieldFormatterBranding($elements);
    $elements['#attached']['library'][] = 'formatter_suite/formatter_suite.fieldformatter';

    // Add description.
    //
    // Use a large negative weight to insure it comes first.
    $elements['description'] = [
      '#type' => 'html_tag',
      '#tag' => 'div',
      '#value' => $this
        ->getDescription(),
      '#weight' => -1000,
      '#attributes' => [
        'class' => [
          'formatter_suite-settings-description',
        ],
      ],
    ];
    $weight = 0;

    // Prompt for each setting.
    if ($linkTitleDisabled === TRUE) {
      $titleStyles = $this
        ->getTitleStylesFieldNoTitle();
    }
    else {
      $titleStyles = $this
        ->getTitleStyles();
    }
    $elements['titleStyle'] = [
      '#title' => $this
        ->t('Link title'),
      '#type' => 'select',
      '#options' => $titleStyles,
      '#default_value' => $this
        ->getSetting('titleStyle'),
      '#weight' => $weight++,
      '#wrapper_attributes' => [
        'class' => [
          'formatter_suite-general-link-title-style',
        ],
      ],
      '#attributes' => [
        'class' => [
          'titleStyle-' . $marker,
        ],
      ],
    ];
    $elements['titleCustomText'] = [
      '#title' => $this
        ->t('Custom text'),
      '#type' => 'textfield',
      '#size' => 10,
      '#default_value' => $this
        ->getSetting('titleCustomText'),
      '#weight' => $weight++,
      '#wrapper_attributes' => [
        'class' => [
          'formatter_suite-general-link-title-custom-text',
        ],
      ],
      '#states' => [
        'visible' => [
          '.titleStyle-' . $marker => [
            'value' => 'text_custom',
          ],
        ],
      ],
    ];
    $elements['sectionBreak1'] = [
      '#markup' => '<div class="formatter_suite-section-break"></div>',
      '#weight' => $weight++,
    ];
    $elements['classes'] = [
      '#title' => $this
        ->t('Custom classes'),
      '#type' => 'textfield',
      '#size' => 10,
      '#default_value' => $this
        ->getSetting('classes'),
      '#weight' => $weight++,
      '#attributes' => [
        'autocomplete' => 'off',
        'autocapitalize' => 'none',
        'spellcheck' => 'false',
        'autocorrect' => 'off',
      ],
      '#wrapper_attributes' => [
        'class' => [
          'formatter_suite-general-link-classes',
        ],
      ],
    ];
    $elements['sectionBreak2'] = [
      '#markup' => '<div class="formatter_suite-section-break"></div>',
      '#weight' => $weight++,
    ];
    $elements['showLink'] = [
      '#title' => $this
        ->t('Link to the item'),
      '#type' => 'checkbox',
      '#default_value' => $this
        ->getSetting('showLink'),
      '#weight' => $weight++,
      '#wrapper_attributes' => [
        'class' => [
          'formatter_suite-general-link-show-link',
        ],
      ],
      '#attributes' => [
        'class' => [
          'showLink-' . $marker,
        ],
      ],
    ];
    $elements['openLinkIn'] = [
      '#title' => $this
        ->t('Use link to'),
      '#type' => 'select',
      '#options' => $this
        ->getOpenLinkInValues(),
      '#default_value' => $this
        ->getSetting('openLinkIn'),
      '#weight' => $weight++,
      '#wrapper_attributes' => [
        'class' => [
          'formatter_suite-general-link-open-link-in',
        ],
      ],
      '#states' => [
        'visible' => [
          '.showLink-' . $marker => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
    $elements['linkTopic'] = [
      '#title' => $this
        ->t('Annotate link as'),
      '#type' => 'select',
      '#options' => $this
        ->getLinkTopicValues(),
      '#default_value' => $this
        ->getSetting('linkTopic'),
      '#weight' => $weight++,
      '#wrapper_attributes' => [
        'class' => [
          'formatter_suite-general-link-link-topic',
        ],
      ],
      '#states' => [
        'visible' => [
          '.showLink-' . $marker => [
            'checked' => TRUE,
          ],
        ],
      ],
    ];
    if ($linkIsInternalOnly === FALSE) {
      $elements['noreferrer'] = [
        '#title' => $this
          ->t('Do not pass the current site as the referrer ("noreferrer")'),
        '#type' => 'checkbox',
        '#default_value' => $this
          ->getSetting('noreferrer'),
        '#weight' => $weight++,
        '#wrapper_attributes' => [
          'class' => [
            'formatter_suite-general-link-noreferrer',
          ],
        ],
        '#states' => [
          'visible' => [
            '.showLink-' . $marker => [
              'checked' => TRUE,
            ],
          ],
        ],
      ];
      $elements['noopener'] = [
        '#title' => $this
          ->t('Do not share the current page context ("noopener")'),
        '#type' => 'checkbox',
        '#default_value' => $this
          ->getSetting('noopener'),
        '#weight' => $weight++,
        '#wrapper_attributes' => [
          'class' => [
            'formatter_suite-general-link-noopener',
          ],
        ],
        '#states' => [
          'visible' => [
            '.showLink-' . $marker => [
              'checked' => TRUE,
            ],
          ],
        ],
      ];
    }
    if ($linkIsInternalOnly === FALSE) {
      $elements['nofollow'] = [
        '#title' => $this
          ->t('Do not treat the link as an endorsement ("nofollow")'),
        '#type' => 'checkbox',
        '#default_value' => $this
          ->getSetting('nofollow'),
        '#weight' => $weight++,
        '#wrapper_attributes' => [
          'class' => [
            'formatter_suite-general-link-nofollow',
          ],
        ],
        '#states' => [
          'visible' => [
            '.showLink-' . $marker => [
              'checked' => TRUE,
            ],
          ],
        ],
      ];
    }
    if ($isMultiple === TRUE) {
      $elements['sectionBreak3'] = [
        '#markup' => '<div class="formatter_suite-section-break"></div>',
        '#weight' => $weight++,
      ];
      $elements['listStyle'] = [
        '#title' => $this
          ->t('List style'),
        '#type' => 'select',
        '#options' => $this
          ->getListStyles(),
        '#default_value' => $this
          ->getSetting('listStyle'),
        '#weight' => $weight++,
        '#wrapper_attributes' => [
          'class' => [
            'formatter_suite-general-link-list-style',
          ],
        ],
        '#attributes' => [
          'class' => [
            'listStyle-' . $marker,
          ],
        ],
      ];
      $elements['listSeparator'] = [
        '#title' => $this
          ->t('Separator'),
        '#type' => 'textfield',
        '#size' => 10,
        '#default_value' => $this
          ->getSetting('listSeparator'),
        '#weight' => $weight++,
        '#attributes' => [
          'autocomplete' => 'off',
          'autocapitalize' => 'none',
          'spellcheck' => 'false',
          'autocorrect' => 'off',
        ],
        '#wrapper_attributes' => [
          'class' => [
            'formatter_suite-general-link-list-separator',
          ],
        ],
        '#states' => [
          'visible' => [
            '.listStyle-' . $marker => [
              'value' => 'span',
            ],
          ],
        ],
      ];
    }
    return $elements;
  }

  /**
   * Sanitize settings to insure that they are safe and valid.
   *
   * @internal
   * Drupal's class hierarchy for plugins and their settings does not
   * include a 'validate' function, like that for other classes with forms.
   * Validation must therefore occur on use, rather than on form submission.
   * @endinternal
   */
  protected function sanitizeSettings() {

    // Get field settings.
    $fieldSettings = $this
      ->getFieldSettings();
    $isMultiple = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->isMultiple();
    $linkIsInternalOnly = FALSE;
    if ($fieldSettings['link_type'] === LinkItemInterface::LINK_INTERNAL) {
      $linkIsInternalOnly = TRUE;
    }
    $linkTitleDisabled = FALSE;
    if ($fieldSettings['title'] === DRUPAL_DISABLED) {
      $linkTitleDisabled = TRUE;
    }

    // Get current settings.
    $titleStyle = $this
      ->getSetting('titleStyle');
    $showLink = $this
      ->getSetting('showLink');
    $openLinkIn = $this
      ->getSetting('openLinkIn');
    $noreferrer = $this
      ->getSetting('noreferrer');
    $noopener = $this
      ->getSetting('noopener');
    $nofollow = $this
      ->getSetting('nofollow');
    $linkTopic = $this
      ->getSetting('linkTopic');
    if ($linkIsInternalOnly === TRUE) {

      // For internal-only link fields, do not support setting noreferrer,
      // noopener, or nofollow.
      $noreferrer = FALSE;
      $noopener = FALSE;
      $nofollow = FALSE;
    }

    // Get setting defaults.
    $defaults = $this
      ->defaultSettings();

    // Sanitize & validate.
    //
    // While <select> inputs constrain choices to those we define in the
    // form, it is possible to hack a form response send other values back.
    // So check all <select> choices and use the default when a value is
    // empty or unknown.
    if ($linkTitleDisabled === TRUE) {
      $titleStyles = $this
        ->getTitleStylesFieldNoTitle();
    }
    else {
      $titleStyles = $this
        ->getTitleStyles();
    }
    if (empty($titleStyle) === TRUE || isset($titleStyles[$titleStyle]) === FALSE) {
      if ($linkTitleDisabled === TRUE) {
        $titleStyle = 'text_from_url';
      }
      else {
        $titleStyle = $defaults['titleStyle'];
      }
      $this
        ->setSetting('titleStyle', $titleStyle);
    }
    $openLinkInValues = $this
      ->getOpenLinkInValues();
    if (empty($openLinkIn) === TRUE || isset($openLinkInValues[$openLinkIn]) === FALSE) {
      $openLinkIn = $defaults['openLinkIn'];
      $this
        ->setSetting('openLinkIn', $openLinkIn);
    }
    $linkTopicValues = $this
      ->getLinkTopicValues();
    if (empty($linkTopic) === TRUE || isset($linkTopicValues[$linkTopic]) === FALSE) {
      $linkTopic = $defaults['linkTopic'];
      $this
        ->setSetting('linkTopic', $linkTopic);
    }

    // Insure boolean values are boolean.
    $showLink = boolval($showLink);
    $noreferrer = boolval($noreferrer);
    $noopener = boolval($noopener);
    $nofollow = boolval($nofollow);
    $this
      ->setSetting('showLink', $showLink);
    $this
      ->setSetting('noreferrer', $noreferrer);
    $this
      ->setSetting('noopener', $noopener);
    $this
      ->setSetting('nofollow', $nofollow);
    $listStyle = $this
      ->getSetting('listStyle');
    $listStyles = $this
      ->getListStyles();
    if ($isMultiple === TRUE) {
      if (empty($listStyle) === TRUE || isset($listStyles[$listStyle]) === FALSE) {
        $listStyle = $defaults['listStyle'];
        $this
          ->setSetting('listStyle', $listStyle);
      }
    }

    // Classes and custom title text are not sanitized or validated.
    // They will be added to the link, with appropriate Xss filtering.
  }

  /*---------------------------------------------------------------------
   *
   * View.
   *
   *---------------------------------------------------------------------*/

  /**
   * {@inheritdoc}
   */
  public function viewElements(FieldItemListInterface $items, $langcode) {
    if ($items
      ->isEmpty() === TRUE) {
      return [];
    }
    $this
      ->sanitizeSettings();
    $showLink = $this
      ->getSetting('showLink');
    $entity = $items
      ->getEntity();

    // Prepare custom classes, if any.
    $classes = $this
      ->getSetting('classes');
    if (empty($classes) === TRUE) {
      $classes = [];
    }
    else {

      // Security: Class names are entered by an administrator.
      // They may not include anything but CSS-compatible words, and
      // certainly no HTML.
      //
      // Here, the class text is stripped of HTML tags as a start.
      // A regex tosses unacceptable characters in a CSS class name.
      $classes = strip_tags($classes);
      $classes = mb_ereg_replace('[^_a-zA-Z0-9- ]', '', $classes);
      if ($classes === FALSE) {
        $classes = [];
      }
      $classes = explode(' ', $classes);
    }
    $elements = [];
    foreach ($items as $delta => $item) {

      //
      // Get the URL.
      // ------------
      // Get the URL from the field and get an initial set of options,
      // including those that may have been set in the field.
      // Build the URL from the field.
      $url = $item
        ->getUrl();
      if (empty($url) === TRUE) {
        $url = Url::fromRoute('<none>');
      }
      $urlOptions = $item->options + $url
        ->getOptions();
      $url
        ->setOptions($urlOptions);

      //
      // Get the link title.
      // -------------------
      // Use custom text, text from the link, or the URL. If custom text
      // is selected, but there isn't any, fall through to text from the
      // link. If there is none of that, fall through to the URL.
      switch ($this
        ->getSetting('titleStyle')) {
        case 'text_custom':

          // Security: A custom title is entered by an administrator.
          // It may legitimately include HTML entities and minor HTML, but
          // it should not include dangerous HTML.
          //
          // Because it may include HTML, we cannot pass it directly as
          // the '#title' on a link, which will escape the HTML.
          //
          // We therefore use an Xss admin filter to remove any egreggious
          // HTML (such as scripts and styles), and then FormattableMarkup()
          // to mark the resulting text as safe.
          $title = Xss::filterAdmin($this
            ->getSetting('titleCustomText'));
          if (empty($title) === FALSE) {
            $title = new FormattableMarkup($title, []);
            break;
          }

        // Fall-through and use the field's title as the title text.
        default:
        case 'text_from_link':

          // Security: Link text from the link field is entered by
          // a user. It may legitimately include HTML entities and minor
          // HTML, but it should not include dangerous HTML.
          //
          // Because it may include HTML, we cannot pass it directly as the
          // '#title' on a link, which will escape the HTML.
          //
          // We therefore use an Xss strict filter to remove any egreggious
          // HTML (such as scripts and styles, broken HTML, etc), and then
          // FormattableMarkup() to mark the resulting text as safe.
          $title = $item->title;
          if (empty($title) === FALSE) {
            $title = new FormattableMarkup($title, []);
            break;
          }

        // Fall-through and use the URL as the title text.
        case 'text_from_url':

          // Use the URL as entered in the field, BEFORE this formatter adds
          // additional attributes.
          //
          // Security: URL text from the link field is entered by a user.
          // It should be strictly a valid URL.
          //
          // Below we pass it as the '#title' on a link, which will escape
          // any HTML the URL might contain.
          $title = $url
            ->toString();
          break;
      }

      //
      // Build the link.
      // ---------------
      // If the link is disabled, show the title text within a <span>.
      // Otherwise, build a URL and create a link.
      if ($showLink === FALSE) {
        $elements[$delta] = [
          '#type' => 'html_tag',
          '#tag' => 'span',
          '#value' => $title,
          '#attributes' => [
            'class' => $classes,
          ],
          '#cache' => [
            'tags' => $entity
              ->getCacheTags(),
          ],
        ];
      }
      else {
        $rel = '';
        $target = '';
        $download = FALSE;
        switch ($this
          ->getSetting('openLinkIn')) {
          case '_self':
            $target = '_self';
            break;
          case '_blank':
            $target = '_blank';
            break;
          case 'download':
            $download = TRUE;
            break;
        }
        if ($this
          ->getSetting('noreferrer') === TRUE) {
          $rel .= 'noreferrer ';
        }
        if ($this
          ->getSetting('noopener') === TRUE) {
          $rel .= 'noopener ';
        }
        if ($this
          ->getSetting('nofollow') === TRUE) {
          $rel .= 'nofollow ';
        }
        $topic = $this
          ->getSetting('linkTopic');
        if ($topic !== 'any') {
          $rel .= $topic;
        }
        if (empty($rel) === FALSE) {
          $urlOptions['attributes']['rel'] = $rel;
        }
        if (empty($target) === FALSE) {
          $urlOptions['attributes']['target'] = $target;
        }
        if ($download === TRUE) {
          $urlOptions['attributes']['download'] = '';
        }
        $url
          ->setOptions($urlOptions);
        $elements[$delta] = [
          '#type' => 'link',
          '#title' => $title,
          '#options' => $url
            ->getOptions(),
          '#url' => $url,
          '#attributes' => [
            'class' => $classes,
          ],
          '#cache' => [
            'tags' => $entity
              ->getCacheTags(),
          ],
        ];
        if (empty($items[$delta]->_attributes) === FALSE) {

          // There are item attributes. Add them to the link's options.
          $elements[$delta]['#options'] += [
            'attributes' => $items[$delta]->_attributes,
          ];

          // And remove them from the item since they are now included
          // on the link.
          unset($items[$delta]->_attributes);
        }
      }
    }
    if (empty($elements) === TRUE) {
      return [];
    }

    //
    // Add multi-value field processing.
    // ---------------------------------
    // If the field has multiple values, redirect to a theme and pass
    // the list style and separator.
    $isMultiple = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->isMultiple();
    if ($isMultiple === TRUE) {

      // Replace the 'field' theme with one that supports lists.
      $elements['#theme'] = 'formatter_suite_field_list';

      // Set the list style.
      $elements['#list_style'] = $this
        ->getSetting('listStyle');

      // Set the list separator.
      //
      // Security: The list separator is entered by an administrator.
      // It may legitimately include HTML entities and minor HTML, but
      // it should not include dangerous HTML.
      //
      // Because it may include HTML, we cannot pass it as-is and let a TWIG
      // template use {{ }}, which will process the text and corrupt any
      // entered HTML or HTML entities.
      //
      // We therefore use an Xss admin filter to remove any egreggious HTML
      // (such as scripts and styles), and then FormattableMarkup() to mark the
      // resulting text as safe.
      $listSeparator = Xss::filterAdmin($this
        ->getSetting('listSeparator'));
      $elements['#list_separator'] = new FormattableMarkup($listSeparator, []);
    }
    return $elements;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
DependencySerializationTrait::$_entityStorages	protected	property	An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds	protected	property	An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep	public	function		1
DependencySerializationTrait::__wakeup	public	function		2
FormatterBase::$fieldDefinition	protected	property	The field definition.
FormatterBase::$label	protected	property	The label display setting.
FormatterBase::$settings	protected	property	The formatter settings. Overrides PluginSettingsBase::$settings
FormatterBase::$viewMode	protected	property	The view mode.
FormatterBase::create	public static	function	Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create	11
FormatterBase::getFieldSetting	protected	function	Returns the value of a field setting.
FormatterBase::getFieldSettings	protected	function	Returns the array of field settings.
FormatterBase::isApplicable	public static	function	Returns if the formatter can be used for the provided field. Overrides FormatterInterface::isApplicable	14
FormatterBase::prepareView	public	function	Allows formatters to load information for field values being displayed. Overrides FormatterInterface::prepareView	2
FormatterBase::view	public	function	Builds a renderable array for a fully themed field. Overrides FormatterInterface::view	1
FormatterBase::__construct	public	function	Constructs a FormatterBase object. Overrides PluginBase::__construct	11
GeneralLinkFormatter::defaultSettings	public static	function	Defines the default settings for this plugin. Overrides PluginSettingsBase::defaultSettings
GeneralLinkFormatter::getDescription	protected	function	Returns a brief description of the formatter.
GeneralLinkFormatter::getLinkTopicValues	protected static	function	Returns an array of link topic annotation.
GeneralLinkFormatter::getListStyles	protected static	function	Returns an array of list styles.
GeneralLinkFormatter::getOpenLinkInValues	protected static	function	Returns an array of choices for how to open a link.
GeneralLinkFormatter::getTitleStyles	protected static	function	Returns an array of title styles, for fields with titles.
GeneralLinkFormatter::getTitleStylesFieldNoTitle	protected static	function	Returns an array of title styles, for fields without titles.
GeneralLinkFormatter::sanitizeSettings	protected	function	Sanitize settings to insure that they are safe and valid.
GeneralLinkFormatter::settingsForm	public	function	Returns a form to configure settings for the formatter. Overrides FormatterBase::settingsForm
GeneralLinkFormatter::settingsSummary	public	function	Returns a short summary for the current formatter settings. Overrides FormatterBase::settingsSummary
GeneralLinkFormatter::viewElements	public	function	Builds a renderable array for a field value. Overrides FormatterInterface::viewElements
MessengerTrait::$messenger	protected	property	The messenger.	29
MessengerTrait::messenger	public	function	Gets the messenger.	29
MessengerTrait::setMessenger	public	function	Sets the messenger.
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId	public	function	Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId	public	function	Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition	public	function	Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition	3
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
PluginSettingsBase::$defaultSettingsMerged	protected	property	Whether default settings have been merged into the current $settings.
PluginSettingsBase::$thirdPartySettings	protected	property	The plugin settings injected by third party modules.
PluginSettingsBase::calculateDependencies	public	function	Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies	6
PluginSettingsBase::getSetting	public	function	Returns the value of a setting, or its default value if absent. Overrides PluginSettingsInterface::getSetting
PluginSettingsBase::getSettings	public	function	Returns the array of settings, including defaults for missing settings. Overrides PluginSettingsInterface::getSettings
PluginSettingsBase::getThirdPartyProviders	public	function	Gets the list of third parties that store information. Overrides ThirdPartySettingsInterface::getThirdPartyProviders
PluginSettingsBase::getThirdPartySetting	public	function	Gets the value of a third-party setting. Overrides ThirdPartySettingsInterface::getThirdPartySetting
PluginSettingsBase::getThirdPartySettings	public	function	Gets all third-party settings of a given module. Overrides ThirdPartySettingsInterface::getThirdPartySettings
PluginSettingsBase::mergeDefaults	protected	function	Merges default settings values into $settings.
PluginSettingsBase::onDependencyRemoval	public	function	Informs the plugin that some configuration it depends on will be deleted. Overrides PluginSettingsInterface::onDependencyRemoval	3
PluginSettingsBase::setSetting	public	function	Sets the value of a setting for the plugin. Overrides PluginSettingsInterface::setSetting
PluginSettingsBase::setSettings	public	function	Sets the settings for the plugin. Overrides PluginSettingsInterface::setSettings
PluginSettingsBase::setThirdPartySetting	public	function	Sets the value of a third-party setting. Overrides ThirdPartySettingsInterface::setThirdPartySetting
PluginSettingsBase::unsetThirdPartySetting	public	function	Unsets a third-party setting. Overrides ThirdPartySettingsInterface::unsetThirdPartySetting
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	1
StringTranslationTrait::formatPlural	protected	function	Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals	protected	function	Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation	protected	function	Gets the string translation service.
StringTranslationTrait::setStringTranslation	public	function	Sets the string translation service to use.	2
StringTranslationTrait::t	protected	function	Translates a string to the current language or to a given language.

You are here