EntityReferenceItem.php

<?php

namespace Drupal\Core\Field\Plugin\Field\FieldType;

use Drupal\Component\Plugin\Exception\PluginNotFoundException;
use Drupal\Component\Render\FormattableMarkup;
use Drupal\Component\Utility\Html;
use Drupal\Core\Entity\ContentEntityStorageInterface;
use Drupal\Core\Entity\EntityInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Entity\FieldableEntityInterface;
use Drupal\Core\Entity\TypedData\EntityDataDefinition;
use Drupal\Core\Field\Attribute\FieldType;
use Drupal\Core\Field\EntityReferenceFieldItemList;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Field\FieldException;
use Drupal\Core\Field\FieldStorageDefinitionInterface;
use Drupal\Core\Field\PreconfiguredFieldUiOptionsInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Form\OptGroup;
use Drupal\Core\Render\Element;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\StringTranslation\TranslatableMarkup;
use Drupal\Core\TypedData\DataReferenceDefinition;
use Drupal\Core\TypedData\DataReferenceTargetDefinition;
use Drupal\Core\TypedData\OptionsProviderInterface;
use Drupal\Core\Validation\Plugin\Validation\Constraint\AllowedValuesConstraint;

/**
 * Defines the 'entity_reference' entity field type.
 *
 * Supported settings (below the definition's 'settings' key) are:
 * - target_type: The entity type to reference. Required.
 */
class EntityReferenceItem extends EntityReferenceItemBase implements OptionsProviderInterface, PreconfiguredFieldUiOptionsInterface {
    
    /**
     * {@inheritdoc}
     */
    public static function defaultStorageSettings() {
        return [
            'target_type' => \Drupal::moduleHandler()->moduleExists('node') ? 'node' : 'user',
        ] + parent::defaultStorageSettings();
    }
    
    /**
     * {@inheritdoc}
     */
    public static function defaultFieldSettings() {
        return [
            'handler' => 'default',
            'handler_settings' => [],
        ] + parent::defaultFieldSettings();
    }
    
    /**
     * {@inheritdoc}
     */
    public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
        $settings = $field_definition->getSettings();
        $target_type_info = \Drupal::entityTypeManager()->getDefinition($settings['target_type']);
        // If the target entity type doesn't have an ID key, we cannot determine
        // the target_id data type.
        if (!$target_type_info->hasKey('id')) {
            throw new FieldException('Entity type "' . $target_type_info->id() . '" has no ID key and cannot be targeted by entity reference field "' . $field_definition->getName() . '"');
        }
        $target_id_data_type = 'string';
        if ($target_type_info->entityClassImplements(FieldableEntityInterface::class)) {
            $id_definition = \Drupal::service('entity_field.manager')->getBaseFieldDefinitions($settings['target_type'])[$target_type_info->getKey('id')];
            if ($id_definition->getType() === 'integer') {
                $target_id_data_type = 'integer';
            }
        }
        if ($target_id_data_type === 'integer') {
            $target_id_definition = DataReferenceTargetDefinition::create('integer')->setLabel(new TranslatableMarkup('@label ID', [
                '@label' => $target_type_info->getLabel(),
            ]))
                ->setSetting('unsigned', TRUE);
        }
        else {
            $target_id_definition = DataReferenceTargetDefinition::create('string')->setLabel(new TranslatableMarkup('@label ID', [
                '@label' => $target_type_info->getLabel(),
            ]));
        }
        $target_id_definition->setRequired(TRUE);
        $properties['target_id'] = $target_id_definition;
        $properties['entity'] = DataReferenceDefinition::create('entity')->setLabel($target_type_info->getLabel())
            ->setDescription(new TranslatableMarkup('The referenced entity'))
            ->setComputed(TRUE)
            ->setReadOnly(FALSE)
            ->setTargetDefinition(EntityDataDefinition::create($settings['target_type']))
            ->addConstraint('EntityType', $settings['target_type']);
        return $properties;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function storageSettingsSummary(FieldStorageDefinitionInterface $storage_definition) : array {
        $summary = parent::storageSettingsSummary($storage_definition);
        $target_type = $storage_definition->getSetting('target_type');
        $target_type_info = \Drupal::entityTypeManager()->getDefinition($target_type);
        if (!empty($target_type_info)) {
            $summary[] = new TranslatableMarkup('Reference type: @entity_type', [
                '@entity_type' => $target_type_info->getLabel(),
            ]);
        }
        return $summary;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function fieldSettingsSummary(FieldDefinitionInterface $field_definition) : array {
        $summary = parent::fieldSettingsSummary($field_definition);
        $target_type = $field_definition->getFieldStorageDefinition()
            ->getSetting('target_type');
        $handler_settings = $field_definition->getSetting('handler_settings');
        if (!isset($handler_settings['target_bundles'])) {
            return $summary;
        }
        
        /** @var \Drupal\Core\Entity\EntityTypeBundleInfoInterface $entity_bundle_information */
        $entity_bundle_information = \Drupal::service('entity_type.bundle.info');
        $bundle_info = $entity_bundle_information->getBundleInfo($target_type);
        $bundles = array_map(fn($bundle) => $bundle_info[$bundle]['label'], $handler_settings['target_bundles']);
        $bundle_label = \Drupal::entityTypeManager()->getDefinition($target_type)
            ->getBundleLabel();
        if (!empty($bundles)) {
            $summary[] = new FormattableMarkup('@bundle: @entity_type', [
                '@bundle' => $bundle_label ?: new TranslatableMarkup('Bundle'),
                '@entity_type' => implode(', ', $bundles),
            ]);
        }
        return $summary;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function mainPropertyName() {
        return 'target_id';
    }
    
    /**
     * {@inheritdoc}
     */
    public static function schema(FieldStorageDefinitionInterface $field_definition) {
        $target_type = $field_definition->getSetting('target_type');
        try {
            $target_type_info = \Drupal::entityTypeManager()->getDefinition($target_type);
        } catch (PluginNotFoundException $e) {
            throw new FieldException(sprintf("Field '%s' on entity type '%s' references a target entity type '%s' which does not exist.", $field_definition->getName(), $field_definition->getTargetEntityTypeId(), $target_type));
        }
        $properties = static::propertyDefinitions($field_definition)['target_id'];
        if ($target_type_info->entityClassImplements(FieldableEntityInterface::class) && $properties->getDataType() === 'integer') {
            $columns = [
                'target_id' => [
                    'description' => 'The ID of the target entity.',
                    'type' => 'int',
                    'unsigned' => TRUE,
                ],
            ];
        }
        else {
            $columns = [
                'target_id' => [
                    'description' => 'The ID of the target entity.',
                    'type' => 'varchar_ascii',
                    // If the target entities act as bundles for another entity type,
                    // their IDs should not exceed the maximum length for bundles.
'length' => $target_type_info->getBundleOf() ? EntityTypeInterface::BUNDLE_MAX_LENGTH : 255,
                ],
            ];
        }
        $schema = [
            'columns' => $columns,
            'indexes' => [
                'target_id' => [
                    'target_id',
                ],
            ],
        ];
        return $schema;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getConstraints() {
        $constraints = parent::getConstraints();
        // Remove the 'AllowedValuesConstraint' validation constraint because entity
        // reference fields already use the 'ValidReference' constraint.
        foreach ($constraints as $key => $constraint) {
            if ($constraint instanceof AllowedValuesConstraint) {
                unset($constraints[$key]);
            }
        }
        return $constraints;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setValue($values, $notify = TRUE) {
        if (isset($values) && !is_array($values)) {
            // If either a scalar or an object was passed as the value for the item,
            // assign it to the 'entity' property since that works for both cases.
            $this->set('entity', $values, $notify);
        }
        else {
            parent::setValue($values, FALSE);
            // Support setting the field item with only one property, but make sure
            // values stay in sync if only property is passed.
            // NULL is a valid value, so we use array_key_exists().
            if (is_array($values) && array_key_exists('target_id', $values) && !isset($values['entity'])) {
                $this->onChange('target_id', FALSE);
            }
            elseif (is_array($values) && !array_key_exists('target_id', $values) && isset($values['entity'])) {
                $this->onChange('entity', FALSE);
            }
            elseif (is_array($values) && array_key_exists('target_id', $values) && isset($values['entity'])) {
                // If both properties are passed, verify the passed values match. The
                // only exception we allow is when we have a new entity: in this case
                // its actual id and target_id will be different, due to the new entity
                // marker.
                $entity_id = $this->get('entity')
                    ->getTargetIdentifier();
                // If the entity has been saved and we're trying to set both the
                // target_id and the entity values with a non-null target ID, then the
                // value for target_id should match the ID of the entity value. The
                // entity ID as returned by $entity->id() might be a string, but the
                // provided target_id might be an integer - therefore we have to do a
                // non-strict comparison.
                if (!$this->entity
                    ->isNew() && $values['target_id'] !== NULL && $entity_id != $values['target_id']) {
                    throw new \InvalidArgumentException('The target id and entity passed to the entity reference item do not match.');
                }
            }
            // Notify the parent if necessary.
            if ($notify && $this->parent) {
                $this->parent
                    ->onChange($this->getName());
            }
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function getValue() {
        $values = parent::getValue();
        // If there is an unsaved entity, return it as part of the field item values
        // to ensure idempotency of getValue() / setValue().
        if ($this->hasNewEntity()) {
            $values['entity'] = $this->entity;
        }
        return $values;
    }
    
    /**
     * {@inheritdoc}
     */
    public function onChange($property_name, $notify = TRUE) {
        // Make sure that the target ID and the target property stay in sync.
        if ($property_name == 'entity') {
            $property = $this->get('entity');
            $target_id = $property->isTargetNew() ? NULL : $property->getTargetIdentifier();
            $this->writePropertyValue('target_id', $target_id);
        }
        elseif ($property_name == 'target_id') {
            $this->writePropertyValue('entity', $this->target_id);
        }
        parent::onChange($property_name, $notify);
    }
    
    /**
     * {@inheritdoc}
     */
    public function isEmpty() {
        // Avoid loading the entity by first checking the 'target_id'.
        if ($this->target_id !== NULL) {
            return FALSE;
        }
        if ($this->entity && $this->entity instanceof EntityInterface) {
            return FALSE;
        }
        return TRUE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function preSave() {
        if ($this->hasNewEntity()) {
            // Save the entity if it has not already been saved by some other code.
            if ($this->entity
                ->isNew()) {
                $this->entity
                    ->save();
            }
            // Make sure the parent knows we are updating this property so it can
            // react properly.
            $this->target_id = $this->entity
                ->id();
        }
        if (!$this->isEmpty() && $this->target_id === NULL) {
            $this->target_id = $this->entity
                ->id();
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public static function generateSampleValue(FieldDefinitionInterface $field_definition) {
        // An associative array keyed by the reference type, target type, and
        // bundle.
        static $recursion_tracker = [];
        $manager = \Drupal::service('plugin.manager.entity_reference_selection');
        // Instead of calling $manager->getSelectionHandler($field_definition)
        // replicate the behavior to be able to override the sorting settings.
        $options = [
            'target_type' => $field_definition->getFieldStorageDefinition()
                ->getSetting('target_type'),
            'handler' => $field_definition->getSetting('handler'),
            'entity' => NULL,
        ] + $field_definition->getSetting('handler_settings') ?: [];
        $entity_type = \Drupal::entityTypeManager()->getDefinition($options['target_type']);
        $options['sort'] = [
            'field' => $entity_type->getKey('id'),
            'direction' => 'DESC',
        ];
        $selection_handler = $manager->getInstance($options);
        // Select a random number of references between the last 50 referenceable
        // entities created.
        if ($referenceable = $selection_handler->getReferenceableEntities(NULL, 'CONTAINS', 50)) {
            $group = array_rand($referenceable);
            $values['target_id'] = array_rand($referenceable[$group]);
            return $values;
        }
        // Attempt to create a sample entity, avoiding recursion.
        $entity_storage = \Drupal::entityTypeManager()->getStorage($options['target_type']);
        if ($entity_storage instanceof ContentEntityStorageInterface) {
            $bundle = static::getRandomBundle($entity_type, $options);
            // Track the generated entity by reference type, target type, and bundle.
            $key = $field_definition->getTargetEntityTypeId() . ':' . $options['target_type'] . ':' . $bundle;
            // If entity generation was attempted but did not finish, do not continue.
            if (isset($recursion_tracker[$key])) {
                return [];
            }
            // Mark this as an attempt at generation.
            $recursion_tracker[$key] = TRUE;
            // Mark the sample entity as being a preview.
            $values['entity'] = $entity_storage->createWithSampleValues($bundle, [
                'in_preview' => TRUE,
            ]);
            // Remove the indicator once the entity is successfully generated.
            unset($recursion_tracker[$key]);
            return $values;
        }
    }
    
    /**
     * Gets a bundle for a given entity type and selection options.
     *
     * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
     *   The entity type.
     * @param array $selection_settings
     *   An array of selection settings.
     *
     * @return string|null
     *   Either the bundle string, or NULL if there is no bundle.
     */
    protected static function getRandomBundle(EntityTypeInterface $entity_type, array $selection_settings) {
        if ($entity_type->getKey('bundle')) {
            if (!empty($selection_settings['target_bundles'])) {
                $bundle_ids = $selection_settings['target_bundles'];
            }
            else {
                $bundle_ids = \Drupal::service('entity_type.bundle.info')->getBundleInfo($entity_type->id());
            }
            return array_rand($bundle_ids);
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function storageSettingsForm(array &$form, FormStateInterface $form_state, $has_data) {
        $element['target_type'] = [
            '#type' => 'select',
            '#title' => $this->t('Type of item to reference'),
            '#default_value' => $this->getSetting('target_type'),
            '#required' => TRUE,
            '#disabled' => $has_data,
            '#size' => 1,
        ];
        // Only allow the field to target entity types that have an ID key. This
        // is enforced in ::propertyDefinitions().
        $entity_type_manager = \Drupal::entityTypeManager();
        $filter = function (string $entity_type_id) use ($entity_type_manager) : bool {
            return $entity_type_manager->getDefinition($entity_type_id)
                ->hasKey('id');
        };
        $options = \Drupal::service('entity_type.repository')->getEntityTypeLabels(TRUE);
        foreach ($options as $group_name => $group) {
            $element['target_type']['#options'][$group_name] = array_filter($group, $filter, ARRAY_FILTER_USE_KEY);
        }
        return $element;
    }
    
    /**
     * {@inheritdoc}
     */
    public function fieldSettingsForm(array $form, FormStateInterface $form_state) {
        $field = $form_state->getFormObject()
            ->getEntity();
        // Get all selection plugins for this entity type.
        $selection_plugins = \Drupal::service('plugin.manager.entity_reference_selection')->getSelectionGroups($this->getSetting('target_type'));
        $handlers_options = [];
        foreach (array_keys($selection_plugins) as $selection_group_id) {
            // We only display base plugins (e.g. 'default', 'views', ...) and not
            // entity type specific plugins (e.g. 'default:node', 'default:user',
            // ...).
            if (array_key_exists($selection_group_id, $selection_plugins[$selection_group_id])) {
                $handlers_options[$selection_group_id] = Html::escape($selection_plugins[$selection_group_id][$selection_group_id]['label']);
            }
            elseif (array_key_exists($selection_group_id . ':' . $this->getSetting('target_type'), $selection_plugins[$selection_group_id])) {
                $selection_group_plugin = $selection_group_id . ':' . $this->getSetting('target_type');
                $handlers_options[$selection_group_plugin] = Html::escape($selection_plugins[$selection_group_id][$selection_group_plugin]['base_plugin_label']);
            }
        }
        $form = [
            '#type' => 'container',
            '#process' => [
                [
                    static::class,
                    'fieldSettingsAjaxProcess',
                ],
            ],
            '#element_validate' => [
                [
                    static::class,
                    'fieldSettingsFormValidate',
                ],
            ],
        ];
        $form['handler'] = [
            '#type' => 'details',
            '#title' => $this->t('Reference type'),
            '#open' => TRUE,
            '#tree' => TRUE,
            '#process' => [
                [
                    static::class,
                    'formProcessMergeParent',
                ],
            ],
        ];
        $form['handler']['handler'] = [
            '#type' => 'select',
            '#title' => $this->t('Reference method'),
            '#options' => $handlers_options,
            '#default_value' => $field->getSetting('handler'),
            '#required' => TRUE,
            // Use a form process callback to build #ajax property properly and also
            // to avoid code duplication.
            // @see \Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem::fieldSettingsAjaxProcess()
'#ajax' => TRUE,
            '#limit_validation_errors' => [],
        ];
        $form['handler']['handler_submit'] = [
            '#type' => 'submit',
            '#name' => 'handler_settings_submit',
            '#value' => $this->t('Change handler'),
            '#limit_validation_errors' => [],
            '#attributes' => [
                'class' => [
                    'js-hide',
                ],
            ],
            '#submit' => [
                [
                    static::class,
                    'settingsAjaxSubmit',
                ],
            ],
        ];
        $form['handler']['handler_settings'] = [
            '#type' => 'container',
            '#attributes' => [
                'class' => [
                    'entity_reference-settings',
                ],
            ],
        ];
        $handler = \Drupal::service('plugin.manager.entity_reference_selection')->getSelectionHandler($field);
        $form['handler']['handler_settings'] += $handler->buildConfigurationForm([], $form_state);
        return $form;
    }
    
    /**
     * Form element validation handler; Invokes selection plugin's validation.
     *
     * @param array $form
     *   The form where the settings form is being included in.
     * @param \Drupal\Core\Form\FormStateInterface $form_state
     *   The form state of the (entire) configuration form.
     */
    public static function fieldSettingsFormValidate(array $form, FormStateInterface $form_state) {
        $field = $form_state->getFormObject()
            ->getEntity();
        $handler = \Drupal::service('plugin.manager.entity_reference_selection')->getSelectionHandler($field);
        $handler->validateConfigurationForm($form, $form_state);
    }
    
    /**
     * Determines whether the item holds an unsaved entity.
     *
     * This is notably used for "autocreate" widgets, and more generally to
     * support referencing freshly created entities (they will get saved
     * automatically as the hosting entity gets saved).
     *
     * @return bool
     *   TRUE if the item holds an unsaved entity.
     */
    public function hasNewEntity() {
        return !$this->isEmpty() && $this->target_id === NULL && $this->entity
            ->isNew();
    }
    
    /**
     * {@inheritdoc}
     */
    public static function calculateDependencies(FieldDefinitionInterface $field_definition) {
        $dependencies = parent::calculateDependencies($field_definition);
        $entity_type_manager = \Drupal::entityTypeManager();
        $target_entity_type = $entity_type_manager->getDefinition($field_definition->getFieldStorageDefinition()
            ->getSetting('target_type'));
        // Depend on default values entity types configurations.
        if ($default_value = $field_definition->getDefaultValueLiteral()) {
            $entity_repository = \Drupal::service('entity.repository');
            foreach ($default_value as $value) {
                if (is_array($value) && isset($value['target_uuid'])) {
                    $entity = $entity_repository->loadEntityByUuid($target_entity_type->id(), $value['target_uuid']);
                    // If the entity does not exist do not create the dependency.
                    // @see \Drupal\Core\Field\EntityReferenceFieldItemList::processDefaultValue()
                    if ($entity) {
                        $dependencies[$target_entity_type->getConfigDependencyKey()][] = $entity->getConfigDependencyName();
                    }
                }
            }
        }
        // Depend on target bundle configurations. Dependencies for 'target_bundles'
        // also covers the 'auto_create_bundle' setting, if any, because its value
        // is included in the 'target_bundles' list.
        $handler = $field_definition->getSetting('handler_settings');
        if (!empty($handler['target_bundles'])) {
            if ($bundle_entity_type_id = $target_entity_type->getBundleEntityType()) {
                if ($storage = $entity_type_manager->getStorage($bundle_entity_type_id)) {
                    foreach ($storage->loadMultiple($handler['target_bundles']) as $bundle) {
                        $dependencies[$bundle->getConfigDependencyKey()][] = $bundle->getConfigDependencyName();
                    }
                }
            }
        }
        return $dependencies;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function calculateStorageDependencies(FieldStorageDefinitionInterface $field_definition) {
        $dependencies = parent::calculateStorageDependencies($field_definition);
        $target_entity_type = \Drupal::entityTypeManager()->getDefinition($field_definition->getSetting('target_type'));
        $dependencies['module'][] = $target_entity_type->getProvider();
        return $dependencies;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function onDependencyRemoval(FieldDefinitionInterface $field_definition, array $dependencies) {
        $changed = parent::onDependencyRemoval($field_definition, $dependencies);
        $entity_type_manager = \Drupal::entityTypeManager();
        $target_entity_type = $entity_type_manager->getDefinition($field_definition->getFieldStorageDefinition()
            ->getSetting('target_type'));
        // Try to update the default value config dependency, if possible.
        if ($default_value = $field_definition->getDefaultValueLiteral()) {
            $entity_repository = \Drupal::service('entity.repository');
            foreach ($default_value as $key => $value) {
                if (is_array($value) && isset($value['target_uuid'])) {
                    $entity = $entity_repository->loadEntityByUuid($target_entity_type->id(), $value['target_uuid']);
                    // @see \Drupal\Core\Field\EntityReferenceFieldItemList::processDefaultValue()
                    if ($entity && isset($dependencies[$entity->getConfigDependencyKey()][$entity->getConfigDependencyName()])) {
                        unset($default_value[$key]);
                        $changed = TRUE;
                    }
                }
            }
            if ($changed) {
                $field_definition->setDefaultValue($default_value);
            }
        }
        // Update the 'target_bundles' handler setting if a bundle config dependency
        // has been removed.
        $bundles_changed = FALSE;
        $handler_settings = $field_definition->getSetting('handler_settings');
        if (!empty($handler_settings['target_bundles'])) {
            if ($bundle_entity_type_id = $target_entity_type->getBundleEntityType()) {
                if ($storage = $entity_type_manager->getStorage($bundle_entity_type_id)) {
                    foreach ($storage->loadMultiple($handler_settings['target_bundles']) as $bundle) {
                        if (isset($dependencies[$bundle->getConfigDependencyKey()][$bundle->getConfigDependencyName()])) {
                            unset($handler_settings['target_bundles'][$bundle->id()]);
                            // If this bundle is also used in the 'auto_create_bundle'
                            // setting, disable the auto-creation feature completely.
                            $auto_create_bundle = !empty($handler_settings['auto_create_bundle']) ? $handler_settings['auto_create_bundle'] : FALSE;
                            if ($auto_create_bundle && $auto_create_bundle == $bundle->id()) {
                                $handler_settings['auto_create'] = FALSE;
                                $handler_settings['auto_create_bundle'] = NULL;
                            }
                            $bundles_changed = TRUE;
                        }
                    }
                }
            }
        }
        if ($bundles_changed) {
            $field_definition->setSetting('handler_settings', $handler_settings);
        }
        $changed |= $bundles_changed;
        return $changed;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getPossibleValues(?AccountInterface $account = NULL) {
        return $this->getSettableValues($account);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getPossibleOptions(?AccountInterface $account = NULL) {
        return $this->getSettableOptions($account);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getSettableValues(?AccountInterface $account = NULL) {
        // Flatten options first, because "settable options" may contain group
        // arrays.
        $flatten_options = OptGroup::flattenOptions($this->getSettableOptions($account));
        return array_keys($flatten_options);
    }
    
    /**
     * {@inheritdoc}
     */
    public function getSettableOptions(?AccountInterface $account = NULL) {
        $field_definition = $this->getFieldDefinition();
        if (!($options = \Drupal::service('plugin.manager.entity_reference_selection')->getSelectionHandler($field_definition, $this->getEntity())
            ->getReferenceableEntities())) {
            return [];
        }
        // Rebuild the array by changing the bundle key into the bundle label.
        $target_type = $field_definition->getSetting('target_type');
        $bundles = \Drupal::service('entity_type.bundle.info')->getBundleInfo($target_type);
        $return = [];
        foreach ($options as $bundle => $entity_ids) {
            // The label does not need sanitizing since it is used as an optgroup
            // which is only supported by select elements and auto-escaped.
            $bundle_label = (string) $bundles[$bundle]['label'];
            $return[$bundle_label] = $entity_ids;
        }
        return count($return) == 1 ? reset($return) : $return;
    }
    
    /**
     * Render API callback: Processes the field settings form.
     *
     * @see static::fieldSettingsForm()
     */
    public static function fieldSettingsAjaxProcess($form, FormStateInterface $form_state) {
        static::fieldSettingsAjaxProcessElement($form, $form);
        return $form;
    }
    
    /**
     * Adds the field settings to AJAX form elements.
     *
     * @see static::fieldSettingsAjaxProcess()
     */
    public static function fieldSettingsAjaxProcessElement(&$element, $main_form) {
        // Elements are marked as TRUE ('#ajax' => TRUE,), so not empty.
        if (!empty($element['#ajax'])) {
            $element['#ajax'] = [
                'trigger_as' => [
                    'name' => 'handler_settings_submit',
                ],
                'wrapper' => 'field-combined',
                'element' => $main_form['#array_parents'],
            ];
        }
        foreach (Element::children($element) as $key) {
            static::fieldSettingsAjaxProcessElement($element[$key], $main_form);
        }
    }
    
    /**
     * Render API callback that moves entity reference elements up a level.
     *
     * The elements (i.e. 'handler_settings') are moved for easier processing by
     * the validation and submission handlers.
     *
     * @see _entity_reference_field_settings_process()
     */
    public static function formProcessMergeParent($element) {
        $parents = $element['#parents'];
        array_pop($parents);
        $element['#parents'] = $parents;
        return $element;
    }
    
    /**
     * Submit handler for the non-JS case.
     *
     * @see static::fieldSettingsForm()
     */
    public static function settingsAjaxSubmit($form, FormStateInterface $form_state) {
        $form_storage =& $form_state->getStorage();
        unset($form_storage['default_value_widget']);
        $form_state->setRebuild();
    }
    
    /**
     * {@inheritdoc}
     */
    public static function getPreconfiguredOptions() {
        $options = [];
        // Add all the commonly referenced entity types as distinct pre-configured
        // options.
        $entity_types = \Drupal::entityTypeManager()->getDefinitions();
        $common_references = array_filter($entity_types, function (EntityTypeInterface $entity_type) {
            return $entity_type->isCommonReferenceTarget();
        });
        
        /** @var \Drupal\Core\Entity\EntityTypeInterface $entity_type */
        foreach ($common_references as $entity_type) {
            $options[$entity_type->id()] = [
                'label' => $entity_type->getLabel(),
                'field_storage_config' => [
                    'settings' => [
                        'target_type' => $entity_type->id(),
                    ],
                ],
            ];
        }
        return $options;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function getReferenceableBundles(FieldDefinitionInterface $field_definition) : array {
        $settings = $field_definition->getSettings();
        $target_type_id = $settings['target_type'];
        $handler_settings = $settings['handler_settings'];
        $has_target_bundles = isset($handler_settings['target_bundles']) && !empty($handler_settings['target_bundles']);
        $target_bundles = $has_target_bundles ? $handler_settings['target_bundles'] : array_keys(\Drupal::service('entity_type.bundle.info')->getBundleInfo($target_type_id));
        return [
            $target_type_id => $target_bundles,
        ];
    }

}