clean install

web/core/modules/taxonomy/src/Plugin/EntityReferenceSelection/TermSelection.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\EntityReferenceSelection;
+
+use Drupal\Component\Utility\Html;
+use Drupal\Core\Entity\Attribute\EntityReferenceSelection;
+use Drupal\Core\Entity\Plugin\EntityReferenceSelection\DefaultSelection;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\taxonomy\Entity\Vocabulary;
+
+/**
+ * Provides specific access control for the taxonomy_term entity type.
+ */
+#[EntityReferenceSelection(
+  id: "default:taxonomy_term",
+  label: new TranslatableMarkup("Taxonomy Term selection"),
+  entity_types: ["taxonomy_term"],
+  group: "default",
+  weight: 1
+)]
+class TermSelection extends DefaultSelection {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defaultConfiguration() {
+    return [
+      'sort' => [
+        'field' => 'name',
+        'direction' => 'asc',
+      ],
+    ] + parent::defaultConfiguration();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
+    $form = parent::buildConfigurationForm($form, $form_state);
+
+    // Sorting is not possible for taxonomy terms because we use
+    // \Drupal\taxonomy\TermStorageInterface::loadTree() to retrieve matches.
+    $form['sort']['#access'] = FALSE;
+
+    return $form;
+
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getReferenceableEntities($match = NULL, $match_operator = 'CONTAINS', $limit = 0) {
+    if ($match || $limit) {
+      return parent::getReferenceableEntities($match, $match_operator, $limit);
+    }
+
+    $options = [];
+
+    $bundles = $this->entityTypeBundleInfo->getBundleInfo('taxonomy_term');
+    $bundle_names = $this->getConfiguration()['target_bundles'] ?: array_keys($bundles);
+
+    $has_admin_access = $this->currentUser->hasPermission('administer taxonomy');
+    $unpublished_terms = [];
+    foreach ($bundle_names as $bundle) {
+      if ($vocabulary = Vocabulary::load($bundle)) {
+        /** @var \Drupal\taxonomy\TermInterface[] $terms */
+        if ($terms = $this->entityTypeManager->getStorage('taxonomy_term')->loadTree($vocabulary->id(), 0, NULL, TRUE)) {
+          foreach ($terms as $term) {
+            if (!$has_admin_access && (!$term->isPublished() || in_array($term->parent->target_id, $unpublished_terms))) {
+              $unpublished_terms[] = $term->id();
+              continue;
+            }
+            $options[$vocabulary->id()][$term->id()] = str_repeat('-', $term->depth) . Html::escape($this->entityRepository->getTranslationFromContext($term)->label());
+          }
+        }
+      }
+    }
+
+    return $options;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function countReferenceableEntities($match = NULL, $match_operator = 'CONTAINS') {
+    if ($match) {
+      return parent::countReferenceableEntities($match, $match_operator);
+    }
+
+    $total = 0;
+    $referenceable_entities = $this->getReferenceableEntities($match, $match_operator, 0);
+    foreach ($referenceable_entities as $entities) {
+      $total += count($entities);
+    }
+    return $total;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function buildEntityQuery($match = NULL, $match_operator = 'CONTAINS') {
+    $query = parent::buildEntityQuery($match, $match_operator);
+
+    // Adding the 'taxonomy_term_access' tag is sadly insufficient for terms:
+    // core requires us to also know about the concept of 'published' and
+    // 'unpublished'.
+    if (!$this->currentUser->hasPermission('administer taxonomy')) {
+      $query->condition('status', 1);
+    }
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function createNewEntity($entity_type_id, $bundle, $label, $uid) {
+    $term = parent::createNewEntity($entity_type_id, $bundle, $label, $uid);
+
+    // In order to create a referenceable term, it needs to published.
+    /** @var \Drupal\taxonomy\TermInterface $term */
+    $term->setPublished();
+
+    return $term;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateReferenceableNewEntities(array $entities) {
+    $entities = parent::validateReferenceableNewEntities($entities);
+    // Mirror the conditions checked in buildEntityQuery().
+    if (!$this->currentUser->hasPermission('administer taxonomy')) {
+      $entities = array_filter($entities, function ($term) {
+        /** @var \Drupal\taxonomy\TermInterface $term */
+        return $term->isPublished();
+      });
+    }
+    return $entities;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/Field/FieldFormatter/EntityReferenceTaxonomyTermRssFormatter.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\Field\FieldFormatter;
+
+use Drupal\Core\Field\Attribute\FieldFormatter;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\Core\Url;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\Plugin\Field\FieldFormatter\EntityReferenceFormatterBase;
+
+/**
+ * Plugin implementation of the 'entity reference taxonomy term RSS' formatter.
+ */
+#[FieldFormatter(
+  id: 'entity_reference_rss_category',
+  label: new TranslatableMarkup('RSS category'),
+  description: new TranslatableMarkup('Display reference to taxonomy term in RSS.'),
+  field_types: [
+    'entity_reference',
+  ],
+)]
+class EntityReferenceTaxonomyTermRssFormatter extends EntityReferenceFormatterBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function viewElements(FieldItemListInterface $items, $langcode) {
+    $parent_entity = $items->getEntity();
+    $elements = [];
+
+    foreach ($this->getEntitiesToView($items, $langcode) as $entity) {
+      $parent_entity->rss_elements[] = [
+        'key' => 'category',
+        'value' => $entity->label(),
+        'attributes' => [
+          'domain' => $entity->id() ? Url::fromRoute('entity.taxonomy_term.canonical', ['taxonomy_term' => $entity->id()], ['absolute' => TRUE])->toString() : '',
+        ],
+      ];
+    }
+
+    return $elements;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function isApplicable(FieldDefinitionInterface $field_definition) {
+    // This formatter is only available for taxonomy terms.
+    return $field_definition->getFieldStorageDefinition()->getSetting('target_type') == 'taxonomy_term';
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyTermHierarchyConstraint.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\Validation\Constraint;
+
+use Drupal\Core\Entity\Plugin\Validation\Constraint\CompositeConstraintBase;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\Core\Validation\Attribute\Constraint;
+
+/**
+ * Validation constraint for changing the term hierarchy in pending revisions.
+ */
+#[Constraint(
+  id: 'TaxonomyHierarchy',
+  label: new TranslatableMarkup('Taxonomy term hierarchy', [], ['context' => 'Validation'])
+)]
+class TaxonomyTermHierarchyConstraint extends CompositeConstraintBase {
+
+  /**
+   * The default violation message.
+   *
+   * @var string
+   */
+  public $message = 'You can only change the hierarchy for the <em>published</em> version of this term.';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function coversFields() {
+    return ['parent', 'weight'];
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyTermHierarchyConstraintValidator.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\Validation\Constraint;
+
+use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\taxonomy\TermStorageInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+
+/**
+ * Constraint validator for changing term parents in pending revisions.
+ */
+class TaxonomyTermHierarchyConstraintValidator extends ConstraintValidator implements ContainerInjectionInterface {
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  private $entityTypeManager;
+
+  /**
+   * Creates a new TaxonomyTermHierarchyConstraintValidator instance.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager) {
+    $this->entityTypeManager = $entity_type_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('entity_type.manager')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validate($entity, Constraint $constraint) {
+    $term_storage = $this->entityTypeManager->getStorage($entity->getEntityTypeId());
+    assert($term_storage instanceof TermStorageInterface);
+
+    // Newly created entities should be able to specify a parent.
+    if ($entity && $entity->isNew()) {
+      return;
+    }
+
+    $is_pending_revision = !$entity->isDefaultRevision();
+    $pending_term_ids = $term_storage->getTermIdsWithPendingRevisions();
+    $ancestors = $term_storage->loadAllParents($entity->id());
+    $ancestor_is_pending_revision = (bool) array_intersect_key($ancestors, array_flip($pending_term_ids));
+
+    $new_parents = array_column($entity->parent->getValue(), 'target_id');
+    $original_parents = array_keys($term_storage->loadParents($entity->id())) ?: [0];
+    if (($is_pending_revision || $ancestor_is_pending_revision) && $new_parents != $original_parents) {
+      $this->context->buildViolation($constraint->message)
+        ->atPath('parent')
+        ->addViolation();
+    }
+
+    $original = $term_storage->loadUnchanged($entity->id());
+    if (($is_pending_revision || $ancestor_is_pending_revision) && !$entity->weight->equals($original->weight)) {
+      $this->context->buildViolation($constraint->message)
+        ->atPath('weight')
+        ->addViolation();
+    }
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/D6TermNodeDeriver.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate;
+
+use Drupal\Component\Plugin\Derivative\DeriverBase;
+use Drupal\Component\Plugin\PluginManagerInterface;
+use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
+use Drupal\migrate\Plugin\MigrationDeriverTrait;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Deriver for Drupal 6 term node migrations based on vocabularies.
+ */
+class D6TermNodeDeriver extends DeriverBase implements ContainerDeriverInterface {
+  use MigrationDeriverTrait;
+
+  /**
+   * The base plugin ID this derivative is for.
+   *
+   * @var string
+   */
+  protected $basePluginId;
+
+  /**
+   * The migration plugin manager.
+   *
+   * @var \Drupal\Component\Plugin\PluginManagerInterface
+   */
+  protected $migrationPluginManager;
+
+  /**
+   * D6TermNodeDeriver constructor.
+   *
+   * @param string $base_plugin_id
+   *   The base plugin ID this derivative is for.
+   * @param \Drupal\Component\Plugin\PluginManagerInterface $migration_plugin_manager
+   *   The migration plugin manager.
+   */
+  public function __construct($base_plugin_id, PluginManagerInterface $migration_plugin_manager) {
+    $this->basePluginId = $base_plugin_id;
+    $this->migrationPluginManager = $migration_plugin_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, $base_plugin_id) {
+    return new static(
+      $base_plugin_id,
+      $container->get('plugin.manager.migration')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDerivativeDefinitions($base_plugin_definition, $base_plugin_definitions = NULL) {
+    try {
+      foreach (static::getSourcePlugin('d6_taxonomy_vocabulary') as $row) {
+        $source_vid = $row->getSourceProperty('vid');
+        $definition = $base_plugin_definition;
+        $definition['source']['vid'] = $source_vid;
+        // migrate_drupal_migration_plugins_alter() adds to this definition.
+        $this->derivatives[$source_vid] = $definition;
+      }
+    }
+    catch (\Exception $e) {
+      // It is possible no D6 tables are loaded so just eat exceptions.
+    }
+    return $this->derivatives;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/D7TaxonomyTermDeriver.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate;
+
+use Drupal\Component\Plugin\Derivative\DeriverBase;
+use Drupal\Core\Database\DatabaseExceptionWrapper;
+use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use Drupal\migrate\Exception\RequirementsException;
+use Drupal\migrate\Plugin\MigrationDeriverTrait;
+use Drupal\migrate_drupal\FieldDiscoveryInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Deriver for Drupal 7 taxonomy term migrations based on vocabularies.
+ */
+class D7TaxonomyTermDeriver extends DeriverBase implements ContainerDeriverInterface {
+  use MigrationDeriverTrait;
+  use StringTranslationTrait;
+
+  /**
+   * The base plugin ID this derivative is for.
+   *
+   * @var string
+   */
+  protected $basePluginId;
+
+  /**
+   * The migration field discovery service.
+   *
+   * @var \Drupal\migrate_drupal\FieldDiscoveryInterface
+   */
+  protected $fieldDiscovery;
+
+  /**
+   * D7TaxonomyTermDeriver constructor.
+   *
+   * @param string $base_plugin_id
+   *   The base plugin ID for the plugin ID.
+   * @param \Drupal\migrate_drupal\FieldDiscoveryInterface $field_discovery
+   *   The migration field discovery service.
+   */
+  public function __construct($base_plugin_id, FieldDiscoveryInterface $field_discovery) {
+    $this->basePluginId = $base_plugin_id;
+    $this->fieldDiscovery = $field_discovery;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, $base_plugin_id) {
+    return new static(
+      $base_plugin_id,
+      $container->get('migrate_drupal.field_discovery')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDerivativeDefinitions($base_plugin_definition) {
+
+    $vocabulary_source_plugin = static::getSourcePlugin('d7_taxonomy_vocabulary');
+    try {
+      $vocabulary_source_plugin->checkRequirements();
+    }
+    catch (RequirementsException $e) {
+      // If the d7_taxonomy_vocabulary requirements failed, that means we do not
+      // have a Drupal source database configured - there is nothing to
+      // generate.
+      return $this->derivatives;
+    }
+
+    try {
+      foreach ($vocabulary_source_plugin as $row) {
+        $bundle = $row->getSourceProperty('machine_name');
+        $values = $base_plugin_definition;
+
+        $values['label'] = $this->t('@label (@type)', [
+          '@label' => $values['label'],
+          '@type' => $row->getSourceProperty('name'),
+        ]);
+        $values['source']['bundle'] = $bundle;
+        $values['destination']['default_bundle'] = $bundle;
+
+        /** @var \Drupal\migrate\Plugin\MigrationInterface $migration */
+        $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($values);
+        $this->fieldDiscovery->addBundleFieldProcesses($migration, 'taxonomy_term', $bundle);
+        $this->derivatives[$bundle] = $migration->getPluginDefinition();
+      }
+    }
+    catch (DatabaseExceptionWrapper $e) {
+      // Once we begin iterating the source plugin it is possible that the
+      // source tables will not exist. This can happen when the
+      // MigrationPluginManager gathers up the migration definitions but we do
+      // not actually have a Drupal 7 source database.
+    }
+
+    return $this->derivatives;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/destination/EntityTaxonomyVocabulary.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\taxonomy\Plugin\migrate\destination;
+
+use Drupal\migrate\Attribute\MigrateDestination;
+use Drupal\migrate\Plugin\migrate\destination\EntityConfigBase;
+use Drupal\migrate\Row;
+
+/**
+ * Migration destination for taxonomy vocabulary.
+ */
+#[MigrateDestination('entity:taxonomy_vocabulary')]
+class EntityTaxonomyVocabulary extends EntityConfigBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getEntity(Row $row, array $old_destination_id_values) {
+    /** @var \Drupal\taxonomy\VocabularyInterface $vocabulary */
+    $vocabulary = parent::getEntity($row, $old_destination_id_values);
+
+    // Config schema does not allow description to be empty.
+    if (trim($vocabulary->getDescription()) === '') {
+      $vocabulary->set('description', NULL);
+    }
+    return $vocabulary;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/field/TaxonomyTermReference.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\field;
+
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate_drupal\Attribute\MigrateField;
+use Drupal\migrate_drupal\Plugin\migrate\field\FieldPluginBase;
+
+// cspeLL:ignore entityreference
+/**
+ * MigrateField Plugin for Drupal 6 & Drupal 7 taxonomy term reference fields.
+ */
+#[MigrateField(
+  id: 'taxonomy_term_reference',
+  core: [6, 7],
+  type_map: [
+    'taxonomy_term_reference' => 'entity_reference',
+  ],
+  source_module: 'taxonomy',
+  destination_module: 'core',
+)]
+class TaxonomyTermReference extends FieldPluginBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFieldFormatterMap() {
+    return [
+      'taxonomy_term_reference_link' => 'entity_reference_label',
+      'taxonomy_term_reference_plain' => 'entity_reference_label',
+      'taxonomy_term_reference_rss_category' => 'entity_reference_label',
+      'i18n_taxonomy_term_reference_link' => 'entity_reference_label',
+      'i18n_taxonomy_term_reference_plain' => 'entity_reference_label',
+      'entityreference_entity_view' => 'entity_reference_entity_view',
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defineValueProcessPipeline(MigrationInterface $migration, $field_name, $data) {
+    $process = [
+      'plugin' => 'sub_process',
+      'source' => $field_name,
+      'process' => [
+        'target_id' => 'tid',
+      ],
+    ];
+    $migration->setProcessOfProperty($field_name, $process);
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/process/ForumVocabulary.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\process;
+
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\ProcessPluginBase;
+use Drupal\migrate\Row;
+
+/**
+ * Checks if the vocabulary being migrated is the one used for forums.
+ *
+ * Drupal 8 Forum is expecting specific machine names for its field and
+ * vocabulary names. This process plugin forces a given machine name to the
+ * field or vocabulary that is being migrated.
+ *
+ * The 'forum_vocabulary' source property is evaluated in the
+ * d6_taxonomy_vocabulary or d7_taxonomy_vocabulary source plugins and is set to
+ * true if the vocabulary vid being migrated is the same as the one in the
+ * 'forum_nav_vocabulary' variable on the source site.
+ *
+ * Example:
+ *
+ * @code
+ * process:
+ *   field_name:
+ *     plugin: forum_vocabulary
+ *     machine_name: taxonomy_forums
+ * @endcode
+ *
+ * @deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use
+ *   \Drupal\forum\Plugin\migrate\process\ForumVocabulary instead.
+ *
+ * @see https://www.drupal.org/node/3387830
+ */
+class ForumVocabulary extends ProcessPluginBase {
+
+  /**
+   * Constructs a MigrationLookup object.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition) {
+    @trigger_error(__CLASS__ . 'is deprecated in drupal:10.1.0 and is removed from drupal:11.0.0. Use \Drupal\forum\Plugin\migrate\process\ForumVocabulary instead. See https://www.drupal.org/node/3387830', E_USER_DEPRECATED);
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function transform($value, MigrateExecutableInterface $migrate_executable, Row $row, $destination_property) {
+    if ($row->getSourceProperty('forum_vocabulary') && !empty($this->configuration['machine_name'])) {
+      $value = $this->configuration['machine_name'];
+    }
+    return $value;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/process/TargetBundle.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\process;
+
+use Drupal\migrate\Attribute\MigrateProcess;
+use Drupal\migrate\MigrateExecutableInterface;
+use Drupal\migrate\ProcessPluginBase;
+use Drupal\migrate\Row;
+
+/**
+ * Converts a Drupal 6 vocabulary ID to a target bundle array.
+ */
+#[MigrateProcess('target_bundle')]
+class TargetBundle extends ProcessPluginBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function transform($value, MigrateExecutableInterface $migrate_executable, Row $row, $destination_property) {
+    $target_bundle = [];
+    $vid = $row->get('@_vid');
+    $target_bundle[$vid] = $vid;
+    return $target_bundle;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/Term.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+// cspell:ignore trid
+
+/**
+ * Drupal 6 taxonomy term source from database.
+ *
+ * Available configuration keys:
+ * - bundle: (optional) The taxonomy vocabulary (vid) to filter terms retrieved
+ *   from the source - can be an integer or an array. If omitted, all terms are
+ *   retrieved.
+ *
+ * Examples:
+ *
+ * @code
+ * source:
+ *   plugin: d6_taxonomy_term
+ *   bundle: 0
+ * @endcode
+ *
+ * In this example terms of vocabulary with 'vid' equal to 0 are retrieved from
+ * the source database.
+ *
+ * @code
+ * source:
+ *   plugin: d6_taxonomy_term
+ *   bundle: [1, 3, 5]
+ * @endcode
+ *
+ * In this example terms of vocabularies with 'vid' one of 1, 3, 5 are retrieved
+ * from the source database.
+ *
+ * For additional configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @todo Support term_relation, term_synonym table if possible.
+ *
+ * @MigrateSource(
+ *   id = "d6_taxonomy_term",
+ *   source_module = "taxonomy"
+ * )
+ */
+class Term extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('term_data', 'td')
+      ->fields('td')
+      ->distinct()
+      ->orderBy('td.tid');
+
+    if (isset($this->configuration['bundle'])) {
+      $query->condition('td.vid', (array) $this->configuration['bundle'], 'IN');
+    }
+
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'tid' => $this->t('The term ID.'),
+      'vid' => $this->t('Existing term VID'),
+      'name' => $this->t('The name of the term.'),
+      'description' => $this->t('The term description.'),
+      'weight' => $this->t('Weight'),
+      'parent' => $this->t("The Drupal term IDs of the term's parents."),
+    ];
+    if (isset($this->configuration['translations'])) {
+      $fields['language'] = $this->t('The term language.');
+      $fields['trid'] = $this->t('Translation ID.');
+    }
+    return $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    // Find parents for this row.
+    $parents = $this->select('term_hierarchy', 'th')
+      ->fields('th', ['parent', 'tid'])
+      ->condition('tid', $row->getSourceProperty('tid'))
+      ->execute()
+      ->fetchCol();
+    $row->setSourceProperty('parent', $parents);
+
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['tid']['type'] = 'integer';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/TermLocalizedTranslation.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Row;
+
+// cspell:ignore ltlanguage objectid
+
+/**
+ * Drupal 6 i18n taxonomy terms source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\taxonomy\Plugin\migrate\source\d6\Term
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d6_term_localized_translation",
+ *   source_module = "i18ntaxonomy"
+ * )
+ */
+class TermLocalizedTranslation extends Term {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    // Ideally, the query would return rows for each language for each taxonomy
+    // term with the translations for both the name and description or just the
+    // name translation or just the description translation. That query quickly
+    // became complex and would be difficult to maintain.
+    // Therefore, build a query based on i18nstrings table where each row has
+    // the translation for only one property, either name or description. The
+    // method prepareRow() is then used to obtain the translation for the other
+    // property.
+    $query = parent::query();
+    $query->addField('td', 'language', 'td.language');
+
+    // Add in the property, which is either name or description.
+    // Cast td.tid as char for PostgreSQL compatibility.
+    $query->leftJoin('i18n_strings', 'i18n', 'CAST([td].[tid] AS CHAR(255)) = [i18n].[objectid]');
+    $query->condition('i18n.type', 'term');
+    $query->addField('i18n', 'lid');
+    $query->addField('i18n', 'property');
+
+    // Add in the translation for the property.
+    $query->innerJoin('locales_target', 'lt', '[i18n].[lid] = [lt].[lid]');
+    $query->addField('lt', 'language', 'lt.language');
+    $query->addField('lt', 'translation');
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    $language = $row->getSourceProperty('ltlanguage');
+    $row->setSourceProperty('language', $language);
+    $tid = $row->getSourceProperty('tid');
+
+    // If this row has been migrated it is a duplicate then skip it.
+    if ($this->idMap->lookupDestinationIds(['tid' => $tid, 'language' => $language])) {
+      return FALSE;
+    }
+
+    // Save the translation for this property.
+    $property = $row->getSourceProperty('property');
+    $row->setSourceProperty($property . '_translated', $row->getSourceProperty('translation'));
+
+    // Get the translation, if one exists, for the property not already in the
+    // row.
+    $other_property = ($property == 'name') ? 'description' : 'name';
+    $query = $this->select('i18n_strings', 'i18n')
+      ->fields('i18n', ['lid'])
+      ->condition('i18n.type', 'term')
+      ->condition('i18n.property', $other_property)
+      ->condition('i18n.objectid', $tid);
+    $query->leftJoin('locales_target', 'lt', '[i18n].[lid] = [lt].[lid]');
+    $query->condition('lt.language', $language);
+    $query->addField('lt', 'translation');
+    $results = $query->execute()->fetchAssoc();
+    if ($results) {
+      $row->setSourceProperty($other_property . '_translated', $results['translation']);
+    }
+    else {
+      // The translation does not exist.
+      $row->setSourceProperty($other_property . '_translated', NULL);
+    }
+
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'language' => $this->t('Language for this term.'),
+      'name_translated' => $this->t('Term name translation.'),
+      'description_translated' => $this->t('Term description translation.'),
+    ];
+    return parent::fields() + $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['language']['type'] = 'string';
+    $ids['language']['alias'] = 'lt';
+    return parent::getIds() + $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/TermNode.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Drupal 6 term/node relationships (current revision) source from database.
+ *
+ * Available configuration keys:
+ * - vid: (optional) The taxonomy vocabulary (vid) to filter terms retrieved
+ *   from the source - should be an integer. If omitted, all terms are
+ *   retrieved.
+ *
+ * Example:
+ *
+ * @code
+ * source:
+ *   plugin: d6_term_node
+ *   vid: 7
+ * @endcode
+ *
+ * In this example the relations between nodes and terms are retrieved from
+ * the source database. Source rows include only terms that belong to the
+ * vocabulary with 'vid' equal to 7.
+ *
+ * For additional configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d6_term_node",
+ *   source_module = "taxonomy"
+ * )
+ */
+class TermNode extends DrupalSqlBase {
+
+  /**
+   * The join options between the node and the term node table.
+   */
+  const JOIN = '[tn].[vid] = [n].[vid]';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('term_node', 'tn')
+      ->distinct()
+      ->fields('tn', ['nid', 'vid'])
+      ->fields('n', ['type']);
+    // Because this is an inner join it enforces the current revision.
+    $query->innerJoin('term_data', 'td', '[td].[tid] = [tn].[tid] AND [td].[vid] = :vid', [':vid' => $this->configuration['vid']]);
+    $query->innerJoin('node', 'n', static::JOIN);
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'nid' => $this->t('The node revision ID.'),
+      'vid' => $this->t('The node revision ID.'),
+      'tid' => $this->t('The term ID.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    // Select the terms belonging to the revision selected.
+    $query = $this->select('term_node', 'tn')
+      ->fields('tn', ['tid'])
+      ->condition('n.nid', $row->getSourceProperty('nid'));
+    $query->join('node', 'n', static::JOIN);
+    $query->innerJoin('term_data', 'td', '[td].[tid] = [tn].[tid] AND [td].[vid] = :vid', [':vid' => $this->configuration['vid']]);
+    $row->setSourceProperty('tid', $query->execute()->fetchCol());
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['vid']['type'] = 'integer';
+    $ids['vid']['alias'] = 'tn';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/TermNodeRevision.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+/**
+ * Drupal 6 term/node relationships (non-current revision) source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\taxonomy\Plugin\migrate\source\d6\TermNode
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d6_term_node_revision",
+ *   source_module = "taxonomy"
+ * )
+ */
+class TermNodeRevision extends TermNode {
+
+  /**
+   * {@inheritdoc}
+   */
+  const JOIN = 'tn.nid = n.nid AND tn.vid != n.vid';
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/Vocabulary.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+
+/**
+ * Drupal 6 vocabularies source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d6_taxonomy_vocabulary",
+ *   source_module = "taxonomy"
+ * )
+ */
+class Vocabulary extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('vocabulary', 'v')
+      ->fields('v', [
+        'vid',
+        'name',
+        'description',
+        'help',
+        'relations',
+        'hierarchy',
+        'multiple',
+        'required',
+        'tags',
+        'module',
+        'weight',
+      ]);
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'vid' => $this->t('The vocabulary ID.'),
+      'name' => $this->t('The name of the vocabulary.'),
+      'description' => $this->t('The description of the vocabulary.'),
+      'help' => $this->t('Help text to display for the vocabulary.'),
+      'relations' => $this->t('Whether or not related terms are enabled within the vocabulary. (0 = disabled, 1 = enabled)'),
+      'hierarchy' => $this->t('The type of hierarchy allowed within the vocabulary. (0 = disabled, 1 = single, 2 = multiple)'),
+      'multiple' => $this->t('Whether or not multiple terms from this vocabulary may be assigned to a node. (0 = disabled, 1 = enabled)'),
+      'required' => $this->t('Whether or not terms are required for nodes using this vocabulary. (0 = disabled, 1 = enabled)'),
+      'tags' => $this->t('Whether or not free tagging is enabled for the vocabulary. (0 = disabled, 1 = enabled)'),
+      'weight' => $this->t('The weight of the vocabulary in relation to other vocabularies.'),
+      'parents' => $this->t("The Drupal term IDs of the term's parents."),
+      'node_types' => $this->t('The names of the node types the vocabulary may be used with.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    // Find node types for this row.
+    $node_types = $this->select('vocabulary_node_types', 'nt')
+      ->fields('nt', ['type', 'vid'])
+      ->condition('vid', $row->getSourceProperty('vid'))
+      ->execute()
+      ->fetchCol();
+    $row->setSourceProperty('node_types', $node_types);
+    $row->setSourceProperty('cardinality', ($row->getSourceProperty('tags') == 1 || $row->getSourceProperty('multiple') == 1) ? FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED : 1);
+
+    // If the vocabulary being migrated is the one defined in the
+    // 'forum_nav_vocabulary' variable, set the 'forum_vocabulary' source
+    // property to true so we know this is the vocabulary used by Forum.
+    if ($this->variableGet('forum_nav_vocabulary', 0) == $row->getSourceProperty('vid')) {
+      $row->setSourceProperty('forum_vocabulary', TRUE);
+    }
+
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['vid']['type'] = 'integer';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/VocabularyPerType.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Row;
+
+// cspell:ignore localizable
+
+/**
+ * Drupal 6 vocabularies with associated node types source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d6_taxonomy_vocabulary_per_type",
+ *   source_module = "taxonomy"
+ * )
+ */
+class VocabularyPerType extends Vocabulary {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = parent::query();
+    $query->join('vocabulary_node_types', 'nt', '[v].[vid] = [nt].[vid]');
+    $query->fields('nt', ['type']);
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    // Get the i18n taxonomy translation setting for this vocabulary.
+    // 0 - No multilingual options
+    // 1 - Localizable terms. Run through the localization system.
+    // 2 - Predefined language for a vocabulary and its terms.
+    // 3 - Per-language terms, translatable (referencing terms with different
+    // languages) but not localizable.
+    $i18ntaxonomy_vocab = $this->variableGet('i18ntaxonomy_vocabulary', []);
+    $vid = $row->getSourceProperty('vid');
+    $i18ntaxonomy_vocabulary = FALSE;
+    if (array_key_exists($vid, $i18ntaxonomy_vocab)) {
+      $i18ntaxonomy_vocabulary = $i18ntaxonomy_vocab[$vid];
+    }
+    $row->setSourceProperty('i18ntaxonomy_vocabulary', $i18ntaxonomy_vocabulary);
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['vid']['type'] = 'integer';
+    $ids['vid']['alias'] = 'nt';
+    $ids['type']['type'] = 'string';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d6/VocabularyTranslation.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+// cspell:ignore ltlanguage objectindex
+
+/**
+ * Drupal 6 i18n vocabulary translations source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d6_taxonomy_vocabulary_translation",
+ *   source_module = "i18ntaxonomy"
+ * )
+ */
+class VocabularyTranslation extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('vocabulary', 'v')
+      ->fields('v')
+      ->fields('i18n', ['lid', 'type', 'property', 'objectid'])
+      ->fields('lt', ['lid', 'translation'])
+      ->condition('i18n.type', 'vocabulary');
+    $query->addField('lt', 'language', 'lt.language');
+    // The i18n_strings table has two columns containing the object ID, objectid
+    // and objectindex. The objectid column is a text field. Therefore, for the
+    // join to work in PostgreSQL, use the objectindex field as this is numeric
+    // like the vid field.
+    $query->join('i18n_strings', 'i18n', '[v].[vid] = [i18n].[objectindex]');
+    $query->innerJoin('locales_target', 'lt', '[lt].[lid] = [i18n].[lid]');
+
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'vid' => $this->t('The vocabulary ID.'),
+      'language' => $this->t('Language for this field.'),
+      'property' => $this->t('Name of property being translated.'),
+      'translation' => $this->t('Translation of either the title or explanation.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    // For ease of reading the migration use 'language' as the property name for
+    // the language.
+    $language = $row->getSourceProperty('ltlanguage');
+    $row->setSourceProperty('language', $language);
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['vid']['type'] = 'integer';
+    $ids['language']['type'] = 'string';
+    $ids['language']['alias'] = 'lt';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d7/Term.php

@@ -0,0 +1,163 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d7;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\d7\FieldableEntity;
+
+/**
+ * Drupal 7 taxonomy term source from database.
+ *
+ * Available configuration keys:
+ * - bundle: (optional) The taxonomy vocabulary (machine name) to filter terms
+ *   retrieved from the source - can be a string or an array. If omitted, all
+ *   terms are retrieved.
+ *
+ * Examples:
+ *
+ * @code
+ * source:
+ *   plugin: d7_taxonomy_term
+ *   bundle: tags
+ * @endcode
+ *
+ * In this example terms of 'tags' vocabulary are retrieved from the source
+ * database.
+ *
+ * @code
+ * source:
+ *   plugin: d7_taxonomy_term
+ *   bundle: [tags, forums]
+ * @endcode
+ *
+ * In this example terms of 'tags' and 'forums' vocabularies are retrieved
+ * from the source database.
+ *
+ * For additional configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @todo Support term_relation, term_synonym table if possible.
+ *
+ * @MigrateSource(
+ *   id = "d7_taxonomy_term",
+ *   source_module = "taxonomy"
+ * )
+ */
+class Term extends FieldableEntity {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('taxonomy_term_data', 'td')
+      ->fields('td')
+      ->distinct()
+      ->orderBy('tid');
+    $query->leftJoin('taxonomy_vocabulary', 'tv', '[td].[vid] = [tv].[vid]');
+    $query->addField('tv', 'machine_name');
+
+    if ($this->getDatabase()
+      ->schema()
+      ->fieldExists('taxonomy_vocabulary', 'i18n_mode')) {
+      $query->addField('tv', 'i18n_mode');
+    }
+
+    if (isset($this->configuration['bundle'])) {
+      $query->condition('tv.machine_name', (array) $this->configuration['bundle'], 'IN');
+    }
+
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'tid' => $this->t('The term ID.'),
+      'vid' => $this->t('Existing term VID'),
+      'machine_name' => $this->t('Vocabulary machine name'),
+      'name' => $this->t('The name of the term.'),
+      'description' => $this->t('The term description.'),
+      'weight' => $this->t('Weight'),
+      'parent' => $this->t("The Drupal term IDs of the term's parents."),
+      'format' => $this->t("Format of the term description."),
+    ];
+    return $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    $tid = $row->getSourceProperty('tid');
+    $vocabulary = $row->getSourceProperty('machine_name');
+    $default_language = (array) $this->variableGet('language_default', ['language' => 'en']);
+
+    // If this entity was translated using Entity Translation, we need to get
+    // its source language to get the field values in the right language.
+    // The translations will be migrated by the d7_node_entity_translation
+    // migration.
+    $translatable_vocabularies = array_keys(array_filter($this->variableGet('entity_translation_taxonomy', [])));
+    $entity_translatable = $this->isEntityTranslatable('taxonomy_term') && in_array($vocabulary, $translatable_vocabularies, TRUE);
+
+    if ($entity_translatable) {
+      $source_language = $this->getEntityTranslationSourceLanguage('taxonomy_term', $tid);
+      $language = $entity_translatable && $source_language ? $source_language : $default_language['language'];
+    }
+    // If this is an i18n translation use the default language when i18n_mode
+    // is localized.
+    if ($row->get('i18n_mode')) {
+      $language = ($row->get('i18n_mode') === '1') ? $default_language['language'] : $row->get('language');
+    }
+
+    $language = $language ?? $default_language['language'];
+    $row->setSourceProperty('language', $language);
+
+    // Get Field API field values.
+    foreach ($this->getFields('taxonomy_term', $vocabulary) as $field_name => $field) {
+      // Ensure we're using the right language if the entity and the field are
+      // translatable.
+      $field_language = $entity_translatable && $field['translatable'] ? $language : NULL;
+      $row->setSourceProperty($field_name, $this->getFieldValues('taxonomy_term', $field_name, $tid, NULL, $field_language));
+    }
+
+    // Find parents for this row.
+    $parents = $this->select('taxonomy_term_hierarchy', 'th')
+      ->fields('th', ['parent', 'tid'])
+      ->condition('tid', $row->getSourceProperty('tid'))
+      ->execute()
+      ->fetchCol();
+    $row->setSourceProperty('parent', $parents);
+
+    // If the term name or term description were replaced by real fields using
+    // the Drupal 7 Title module, use the fields value instead of the term name
+    // or term description.
+    if ($this->moduleExists('title')) {
+      $name_field = $row->getSourceProperty('name_field');
+      if (isset($name_field[0]['value'])) {
+        $row->setSourceProperty('name', $name_field[0]['value']);
+      }
+      $description_field = $row->getSourceProperty('description_field');
+      if (isset($description_field[0]['value'])) {
+        $row->setSourceProperty('description', $description_field[0]['value']);
+      }
+      if (isset($description_field[0]['format'])) {
+        $row->setSourceProperty('format', $description_field[0]['format']);
+      }
+    }
+
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['tid']['type'] = 'integer';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d7/TermEntityTranslation.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d7;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\d7\FieldableEntity;
+
+/**
+ * Drupal 7 taxonomy term entity translation source plugin.
+ *
+ * Available configuration keys:
+ * - bundle: (optional) The taxonomy vocabulary (machine name) to filter terms
+ *   retrieved from the source - can be a string or an array. If omitted, all
+ *   terms are retrieved.
+ *
+ * Examples:
+ *
+ * @code
+ * source:
+ *   plugin: d7_taxonomy_term
+ *   bundle: tags
+ * @endcode
+ *
+ * In this example terms of 'tags' vocabulary are retrieved from the source
+ * database.
+ *
+ * @code
+ * source:
+ *   plugin: d7_taxonomy_term
+ *   bundle: [tags, forums]
+ * @endcode
+ *
+ * In this example terms of 'tags' and 'forums' vocabularies are retrieved
+ * from the source database.
+ *
+ * For additional configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_taxonomy_term_entity_translation",
+ *   source_module = "entity_translation"
+ * )
+ */
+class TermEntityTranslation extends FieldableEntity {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('entity_translation', 'et')
+      ->fields('et')
+      ->fields('td', [
+        'name',
+        'description',
+        'format',
+      ])
+      ->fields('tv', [
+        'machine_name',
+      ])
+      ->condition('et.entity_type', 'taxonomy_term')
+      ->condition('et.source', '', '<>');
+
+    $query->innerJoin('taxonomy_term_data', 'td', '[td].[tid] = [et].[entity_id]');
+    $query->innerJoin('taxonomy_vocabulary', 'tv', '[td].[vid] = [tv].[vid]');
+
+    if (isset($this->configuration['bundle'])) {
+      $query->condition('tv.machine_name', (array) $this->configuration['bundle'], 'IN');
+    }
+
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    $tid = $row->getSourceProperty('entity_id');
+    $vocabulary = $row->getSourceProperty('machine_name');
+    $language = $row->getSourceProperty('language');
+
+    // Get Field API field values.
+    foreach ($this->getFields('taxonomy_term', $vocabulary) as $field_name => $field) {
+      // Ensure we're using the right language if the entity is translatable.
+      $field_language = $field['translatable'] ? $language : NULL;
+      $row->setSourceProperty($field_name, $this->getFieldValues('taxonomy_term', $field_name, $tid, NULL, $field_language));
+    }
+
+    // If the term name or term description were replaced by real fields using
+    // the Drupal 7 Title module, use the fields value instead of the term name
+    // or term description.
+    if ($this->moduleExists('title')) {
+      $name_field = $row->getSourceProperty('name_field');
+      if (isset($name_field[0]['value'])) {
+        $row->setSourceProperty('name', $name_field[0]['value']);
+      }
+      $description_field = $row->getSourceProperty('description_field');
+      if (isset($description_field[0]['value'])) {
+        $row->setSourceProperty('description', $description_field[0]['value']);
+      }
+      if (isset($description_field[0]['format'])) {
+        $row->setSourceProperty('format', $description_field[0]['format']);
+      }
+    }
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'entity_type' => $this->t('The entity type this translation relates to'),
+      'entity_id' => $this->t('The entity ID this translation relates to'),
+      'revision_id' => $this->t('The entity revision ID this translation relates to'),
+      'language' => $this->t('The target language for this translation.'),
+      'source' => $this->t('The source language from which this translation was created.'),
+      'uid' => $this->t('The author of this translation.'),
+      'status' => $this->t('Boolean indicating whether the translation is published (visible to non-administrators).'),
+      'translate' => $this->t('A boolean indicating whether this translation needs to be updated.'),
+      'created' => $this->t('The Unix timestamp when the translation was created.'),
+      'changed' => $this->t('The Unix timestamp when the translation was most recently saved.'),
+      'name' => $this->t('The name of the term.'),
+      'description' => $this->t('The term description.'),
+      'format' => $this->t('Format of the term description.'),
+      'machine_name' => $this->t('Vocabulary machine name'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    return [
+      'entity_id' => [
+        'type' => 'integer',
+        'alias' => 'et',
+      ],
+      'language' => [
+        'type' => 'string',
+        'alias' => 'et',
+      ],
+    ];
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d7/TermLocalizedTranslation.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d7;
+
+use Drupal\content_translation\Plugin\migrate\source\I18nQueryTrait;
+use Drupal\migrate\Row;
+
+// cspell:ignore ltlanguage objectid
+
+/**
+ * Drupal 7 i18n taxonomy terms source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\taxonomy\Plugin\migrate\source\d7\Term
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_term_localized_translation",
+ *   source_module = "i18n_taxonomy"
+ * )
+ */
+class TermLocalizedTranslation extends Term {
+
+  use I18nQueryTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    // Ideally, the query would return rows for each language for each taxonomy
+    // term with the translations for both the name and description or just the
+    // name translation or just the description translation. That query quickly
+    // became complex and would be difficult to maintain.
+    // Therefore, build a query based on i18nstrings table where each row has
+    // the translation for only one property, either name or description. The
+    // method prepareRow() is then used to obtain the translation for the other
+    // property.
+    $query = parent::query();
+    $query->addField('td', 'language', 'td.language');
+
+    // Add in the property, which is either name or description.
+    // Cast td.tid as char for PostgreSQL compatibility.
+    $query->leftJoin('i18n_string', 'i18n', 'CAST([td].[tid] AS CHAR(255)) = [i18n].[objectid]');
+    $query->condition('i18n.type', 'term');
+    $query->addField('i18n', 'lid');
+    $query->addField('i18n', 'property');
+
+    // Add in the translation for the property.
+    $query->innerJoin('locales_target', 'lt', '[i18n].[lid] = [lt].[lid]');
+    $query->addField('lt', 'language', 'lt.language');
+    $query->addField('lt', 'translation');
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    if (!parent::prepareRow($row)) {
+      return FALSE;
+    }
+
+    // Override language with ltlanguage.
+    $language = $row->getSourceProperty('ltlanguage');
+    $row->setSourceProperty('language', $language);
+
+    // Set the i18n string table for use in I18nQueryTrait.
+    $this->i18nStringTable = 'i18n_string';
+
+    // Save the translation for the property already in the row.
+    $property_in_row = $row->getSourceProperty('property');
+
+    // Get the translation for the property not already in the row and save it
+    // in the row.
+    $property_not_in_row = ($property_in_row == 'name') ? 'description' : 'name';
+    return $this->getPropertyNotInRowTranslation($row, $property_not_in_row, 'tid', $this->idMap);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'language' => $this->t('Language for this term.'),
+      'name_translated' => $this->t('Term name translation.'),
+      'description_translated' => $this->t('Term description translation.'),
+    ];
+    return parent::fields() + $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['language']['type'] = 'string';
+    $ids['language']['alias'] = 'lt';
+    return parent::getIds() + $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d7/TermTranslation.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d7;
+
+use Drupal\migrate\Row;
+
+/**
+ * Drupal 7 i18n taxonomy terms source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\taxonomy\Plugin\migrate\source\d7\Term
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_taxonomy_term_translation",
+ *   source_module = "i18n_taxonomy"
+ * )
+ */
+class TermTranslation extends Term {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = parent::query();
+    if ($this->database->schema()->fieldExists('taxonomy_term_data', 'language')) {
+      $query->addField('td', 'language', 'td_language');
+    }
+    // Get data when the i18n_mode column exists and it is not the Drupal 7
+    // value I18N_MODE_NONE or I18N_MODE_LOCALIZE. Otherwise, return no data.
+    // @see https://git.drupalcode.org/project/i18n/-/blob/7.x-1.x/i18n.module#L26
+    if ($this->database->schema()->fieldExists('taxonomy_vocabulary', 'i18n_mode')) {
+      $query->addField('tv', 'i18n_mode');
+      $query->condition('tv.i18n_mode', ['0', '1'], 'NOT IN');
+    }
+    else {
+      $query->alwaysFalse();
+    }
+
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    if (!parent::prepareRow($row)) {
+      return FALSE;
+    }
+    $row->setSourceProperty('language', $row->getSourceProperty('td_language'));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'language' => $this->t('Language for this term.'),
+      'name_translated' => $this->t('Term name translation.'),
+      'description_translated' => $this->t('Term description translation.'),
+    ];
+    return parent::fields() + $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['language']['type'] = 'string';
+    $ids['language']['alias'] = 'td';
+    return parent::getIds() + $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d7/Vocabulary.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d7;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Drupal 7 vocabularies source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_taxonomy_vocabulary",
+ *   source_module = "taxonomy"
+ * )
+ */
+class Vocabulary extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('taxonomy_vocabulary', 'v')
+      ->fields('v', [
+        'vid',
+        'name',
+        'description',
+        'hierarchy',
+        'module',
+        'weight',
+        'machine_name',
+      ]);
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'vid' => $this->t('The vocabulary ID.'),
+      'name' => $this->t('The name of the vocabulary.'),
+      'description' => $this->t('The description of the vocabulary.'),
+      'hierarchy' => $this->t('The type of hierarchy allowed within the vocabulary. (0 = disabled, 1 = single, 2 = multiple)'),
+      'module' => $this->t('Module responsible for the vocabulary.'),
+      'weight' => $this->t('The weight of the vocabulary in relation to other vocabularies.'),
+      'machine_name' => $this->t('Unique machine name of the vocabulary.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    // If the vocabulary being migrated is the one defined in the
+    // 'forum_nav_vocabulary' variable, set the 'forum_vocabulary' source
+    // property to true so we know this is the vocabulary used by Forum.
+    if ($this->variableGet('forum_nav_vocabulary', 0) == $row->getSourceProperty('vid')) {
+      $row->setSourceProperty('forum_vocabulary', TRUE);
+    }
+
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['vid']['type'] = 'integer';
+    return $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/migrate/source/d7/VocabularyTranslation.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\migrate\source\d7;
+
+// cspell:ignore objectid objectindex plid textgroup
+
+/**
+ * Drupal 7 i18n vocabulary translations source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_taxonomy_vocabulary_translation",
+ *   source_module = "i18n_taxonomy"
+ * )
+ */
+class VocabularyTranslation extends Vocabulary {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = parent::query();
+    $query->leftJoin('i18n_string', 'i18n', 'CAST ([v].[vid] AS CHAR(222)) = [i18n].[objectid]');
+    $query->innerJoin('locales_target', 'lt', '[lt].[lid] = [i18n].[lid]');
+    $query
+      ->condition('type', 'vocabulary')
+      ->fields('lt')
+      ->fields('i18n');
+    $query->addField('lt', 'lid', 'lt_lid');
+
+    if ($this->getDatabase()
+      ->schema()
+      ->fieldExists('taxonomy_vocabulary', 'language')) {
+      $query->addField('v', 'language', 'v_language');
+    }
+    if ($this->getDatabase()
+      ->schema()
+      ->fieldExists('taxonomy_vocabulary', 'i18n_mode')) {
+      $query->addField('v', 'i18n_mode');
+    }
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    $fields = [
+      'i18n_mode' => $this->t('Internationalization mode.'),
+      'v_language' => $this->t('Language from the taxonomy_vocabulary table.'),
+      'property' => $this->t('Name of property being translated.'),
+      'type' => $this->t('Name of property being translated.'),
+      'objectid' => $this->t('Name of property being translated.'),
+      'lt_lid' => $this->t('Name of property being translated.'),
+      'translation' => $this->t('Translation of either the name or the description.'),
+      'lid' => $this->t('Language string ID'),
+      'textgroup' => $this->t('A module defined group of translations'),
+      'context' => $this->t('Full string ID for quick search: type:objectid:property.'),
+      'objectindex' => $this->t('Integer value of Object ID'),
+      'format' => $this->t('The {filter_format}.format of the string'),
+      'language' => $this->t('Language code from locales_target table'),
+      'plid' => $this->t('Parent lid'),
+      'plural' => $this->t('Plural index number'),
+      'i18n_status' => $this->t('Translation needs update'),
+    ];
+    return parent::fields() + $fields;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids = [];
+    $ids['language']['type'] = 'string';
+    $ids['language']['alias'] = 'lt';
+    $ids['property']['type'] = 'string';
+    return parent::getIds() + $ids;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/argument/IndexTid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument;
+
+use Drupal\taxonomy\Entity\Term;
+use Drupal\views\Attribute\ViewsArgument;
+use Drupal\views\Plugin\views\argument\ManyToOne;
+
+/**
+ * Allow taxonomy term ID(s) as argument.
+ *
+ * @ingroup views_argument_handlers
+ */
+#[ViewsArgument(
+  id: 'taxonomy_index_tid',
+)]
+class IndexTid extends ManyToOne {
+
+  public function titleQuery() {
+    $titles = [];
+    $terms = Term::loadMultiple($this->value);
+    foreach ($terms as $term) {
+      $titles[] = \Drupal::service('entity.repository')->getTranslationFromContext($term)->label();
+    }
+    return $titles;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/argument/IndexTidDepth.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument;
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Entity\EntityRepositoryInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\taxonomy\TaxonomyIndexDepthQueryTrait;
+use Drupal\views\Attribute\ViewsArgument;
+use Drupal\views\Plugin\views\argument\ArgumentPluginBase;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Argument handler for taxonomy terms with depth.
+ *
+ * This handler is actually part of the node table and has some restrictions,
+ * because it uses a subquery to find nodes with.
+ *
+ * @ingroup views_argument_handlers
+ */
+#[ViewsArgument(
+  id: 'taxonomy_index_tid_depth',
+)]
+class IndexTidDepth extends ArgumentPluginBase implements ContainerFactoryPluginInterface {
+  use TaxonomyIndexDepthQueryTrait;
+
+  /**
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   *
+   * @deprecated in drupal:10.3.0 and is removed from drupal:11.0.0. There is no
+   *   replacement.
+   *
+   * @see https://www.drupal.org/node/3427843
+   */
+  protected $termStorage;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, protected EntityStorageInterface|EntityRepositoryInterface $entityRepository) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+
+    if ($entityRepository instanceof EntityStorageInterface) {
+      // @phpstan-ignore-next-line
+      $this->termStorage = $entityRepository;
+      @trigger_error('Calling ' . __CLASS__ . '::__construct() with the $termStorage argument as \Drupal\Core\Entity\EntityStorageInterface is deprecated in drupal:10.3.0 and it will require Drupal\Core\Entity\EntityRepositoryInterface in drupal:11.0.0. See https://www.drupal.org/node/3427843', E_USER_DEPRECATED);
+      $this->entityRepository = \Drupal::service('entity.repository');
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity.repository')
+    );
+  }
+
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+
+    $options['depth'] = ['default' => 0];
+    $options['break_phrase'] = ['default' => FALSE];
+    $options['use_taxonomy_term_path'] = ['default' => FALSE];
+
+    return $options;
+  }
+
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    $form['depth'] = [
+      '#type' => 'weight',
+      '#title' => $this->t('Depth'),
+      '#default_value' => $this->options['depth'],
+      '#description' => $this->t('The depth will match nodes tagged with terms in the hierarchy. For example, if you have the term "fruit" and a child term "apple", with a depth of 1 (or higher) then filtering for the term "fruit" will get nodes that are tagged with "apple" as well as "fruit". If negative, the reverse is true; searching for "apple" will also pick up nodes tagged with "fruit" if depth is -1 (or lower).'),
+    ];
+
+    $form['break_phrase'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Allow multiple values'),
+      '#description' => $this->t('If selected, users can enter multiple values in the form of 1+2+3. Due to the number of JOINs it would require, AND will be treated as OR with this filter.'),
+      '#default_value' => !empty($this->options['break_phrase']),
+    ];
+
+    parent::buildOptionsForm($form, $form_state);
+  }
+
+  /**
+   * Override defaultActions() to remove summary actions.
+   */
+  protected function defaultActions($which = NULL) {
+    if ($which) {
+      if (in_array($which, ['ignore', 'not found', 'empty', 'default'])) {
+        return parent::defaultActions($which);
+      }
+      return;
+    }
+    $actions = parent::defaultActions();
+    unset($actions['summary asc']);
+    unset($actions['summary desc']);
+    unset($actions['summary asc by count']);
+    unset($actions['summary desc by count']);
+    return $actions;
+  }
+
+  public function query($group_by = FALSE) {
+    $this->ensureMyTable();
+
+    if (!empty($this->options['break_phrase'])) {
+      $break = static::breakString($this->argument);
+      if ($break->value === [-1]) {
+        return FALSE;
+      }
+      $tids = $break->value;
+    }
+    else {
+      $tids = $this->argument;
+    }
+
+    $this->addSubQueryJoin($tids);
+  }
+
+  public function title() {
+    $term = $this->entityRepository->getCanonical('taxonomy_term', $this->argument);
+    if (!empty($term)) {
+      return $term->label();
+    }
+    // @todo Review text.
+
+    return $this->t('No name');
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/argument/IndexTidDepthModifier.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\views\Attribute\ViewsArgument;
+use Drupal\views\Plugin\views\argument\ArgumentPluginBase;
+
+/**
+ * Argument handler for to modify depth for a previous term.
+ *
+ * This handler is actually part of the node table and has some restrictions,
+ * because it uses a subquery to find nodes with.
+ *
+ * @ingroup views_argument_handlers
+ */
+#[ViewsArgument(
+  id: 'taxonomy_index_tid_depth_modifier',
+)]
+class IndexTidDepthModifier extends ArgumentPluginBase {
+
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {}
+
+  public function query($group_by = FALSE) {}
+
+  public function preQuery() {
+    // We don't know our argument yet, but it's based upon our position:
+    $argument = $this->view->args[$this->position] ?? NULL;
+    if (!is_numeric($argument)) {
+      return;
+    }
+
+    if ($argument > 10) {
+      $argument = 10;
+    }
+
+    if ($argument < -10) {
+      $argument = -10;
+    }
+
+    // Figure out which argument preceded us.
+    $keys = array_reverse(array_keys($this->view->argument));
+    $skip = TRUE;
+    foreach ($keys as $key) {
+      if ($key == $this->options['id']) {
+        $skip = FALSE;
+        continue;
+      }
+
+      if ($skip) {
+        continue;
+      }
+
+      if (empty($this->view->argument[$key])) {
+        continue;
+      }
+
+      $handler = &$this->view->argument[$key];
+      if (empty($handler->definition['accept depth modifier'])) {
+        continue;
+      }
+
+      // Finally!
+      $handler->options['depth'] = $argument;
+    }
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/argument/Taxonomy.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument;
+
+use Drupal\views\Attribute\ViewsArgument;
+use Drupal\views\Plugin\views\argument\EntityArgument;
+
+/**
+ * Argument handler for basic taxonomy tid.
+ *
+ * @ingroup views_argument_handlers
+ */
+#[ViewsArgument(
+  id: 'taxonomy',
+)]
+class Taxonomy extends EntityArgument {}

web/core/modules/taxonomy/src/Plugin/views/argument/VocabularyVid.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument;
+
+use Drupal\views\Attribute\ViewsArgument;
+use Drupal\views\Plugin\views\argument\EntityArgument;
+
+/**
+ * Argument handler to accept a vocabulary id.
+ *
+ * @ingroup views_argument_handlers
+  */
+#[ViewsArgument(
+  id: 'vocabulary_vid',
+)]
+class VocabularyVid extends EntityArgument {}

web/core/modules/taxonomy/src/Plugin/views/argument_default/Tid.php

@@ -0,0 +1,239 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument_default;
+
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheableDependencyInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Routing\RouteMatchInterface;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\taxonomy\TermInterface;
+use Drupal\views\Attribute\ViewsArgumentDefault;
+use Drupal\views\Plugin\views\argument_default\ArgumentDefaultPluginBase;
+use Drupal\node\NodeInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\taxonomy\VocabularyStorageInterface;
+
+/**
+ * Taxonomy tid default argument.
+ */
+#[ViewsArgumentDefault(
+  id: 'taxonomy_tid',
+  title: new TranslatableMarkup('Taxonomy term ID from URL'),
+)]
+class Tid extends ArgumentDefaultPluginBase implements CacheableDependencyInterface {
+
+  /**
+   * The route match.
+   *
+   * @var \Drupal\Core\Routing\RouteMatchInterface
+   */
+  protected $routeMatch;
+
+  /**
+   * The vocabulary storage.
+   *
+   * @var \Drupal\taxonomy\VocabularyStorageInterface
+   */
+  protected $vocabularyStorage;
+
+  /**
+   * Constructs a new Tid instance.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin ID for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.   *
+   * @param \Drupal\Core\Routing\RouteMatchInterface $route_match
+   *   The route match.
+   * @param \Drupal\taxonomy\VocabularyStorageInterface $vocabulary_storage
+   *   The vocabulary storage.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, RouteMatchInterface $route_match, VocabularyStorageInterface $vocabulary_storage) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+
+    $this->routeMatch = $route_match;
+    $this->vocabularyStorage = $vocabulary_storage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('current_route_match'),
+      $container->get('entity_type.manager')->getStorage('taxonomy_vocabulary')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+
+    $options['term_page'] = ['default' => TRUE];
+    $options['node'] = ['default' => FALSE];
+    $options['anyall'] = ['default' => ','];
+    $options['limit'] = ['default' => FALSE];
+    $options['vids'] = ['default' => []];
+
+    return $options;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    $form['term_page'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Load default filter from term page'),
+      '#default_value' => $this->options['term_page'],
+    ];
+    $form['node'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t("Load default filter from node page, that's good for related taxonomy blocks"),
+      '#default_value' => $this->options['node'],
+    ];
+
+    $form['limit'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Limit terms by vocabulary'),
+      '#default_value' => $this->options['limit'],
+      '#states' => [
+        'visible' => [
+          ':input[name="options[argument_default][taxonomy_tid][node]"]' => ['checked' => TRUE],
+        ],
+      ],
+    ];
+
+    $options = [];
+    $vocabularies = $this->vocabularyStorage->loadMultiple();
+    foreach ($vocabularies as $voc) {
+      $options[$voc->id()] = $voc->label();
+    }
+
+    $form['vids'] = [
+      '#type' => 'checkboxes',
+      '#title' => $this->t('Vocabularies'),
+      '#options' => $options,
+      '#default_value' => $this->options['vids'],
+      '#states' => [
+        'visible' => [
+          ':input[name="options[argument_default][taxonomy_tid][limit]"]' => ['checked' => TRUE],
+          ':input[name="options[argument_default][taxonomy_tid][node]"]' => ['checked' => TRUE],
+        ],
+      ],
+    ];
+
+    $form['anyall'] = [
+      '#type' => 'radios',
+      '#title' => $this->t('Multiple-value handling'),
+      '#default_value' => $this->options['anyall'],
+      '#options' => [
+        ',' => $this->t('Filter to items that share all terms'),
+        '+' => $this->t('Filter to items that share any term'),
+      ],
+      '#states' => [
+        'visible' => [
+          ':input[name="options[argument_default][taxonomy_tid][node]"]' => ['checked' => TRUE],
+        ],
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitOptionsForm(&$form, FormStateInterface $form_state, &$options = []) {
+    // Filter unselected items so we don't unnecessarily store giant arrays.
+    $options['vids'] = array_filter($options['vids']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getArgument() {
+    // Load default argument from taxonomy page.
+    if (!empty($this->options['term_page'])) {
+      if (($taxonomy_term = $this->routeMatch->getParameter('taxonomy_term')) && $taxonomy_term instanceof TermInterface) {
+        return $taxonomy_term->id();
+      }
+    }
+    // Load default argument from node.
+    if (!empty($this->options['node'])) {
+      // Just check, if a node could be detected.
+      if (($node = $this->routeMatch->getParameter('node')) && $node instanceof NodeInterface) {
+        $taxonomy = [];
+        foreach ($node->getFieldDefinitions() as $field) {
+          if ($field->getType() == 'entity_reference' && $field->getSetting('target_type') == 'taxonomy_term') {
+            $taxonomy_terms = $node->{$field->getName()}->referencedEntities();
+            /** @var \Drupal\taxonomy\TermInterface $taxonomy_term */
+            foreach ($taxonomy_terms as $taxonomy_term) {
+              $taxonomy[$taxonomy_term->id()] = $taxonomy_term->bundle();
+            }
+          }
+        }
+        if (!empty($this->options['limit'])) {
+          $tids = [];
+          // Filter by vocabulary
+          foreach ($taxonomy as $tid => $vocab) {
+            if (!empty($this->options['vids'][$vocab])) {
+              $tids[] = $tid;
+            }
+          }
+          return implode($this->options['anyall'], $tids);
+        }
+        // Return all tids.
+        else {
+          return implode($this->options['anyall'], array_keys($taxonomy));
+        }
+      }
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCacheTags() {
+    $tags = parent::getCacheTags();
+    if (!empty($this->options['node'])) {
+      if (($node = $this->routeMatch->getParameter('node')) && $node instanceof NodeInterface) {
+        $tags = Cache::mergeTags($tags, $node->getCacheTags());
+      }
+    }
+    return $tags;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCacheMaxAge() {
+    return Cache::PERMANENT;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCacheContexts() {
+    return ['url'];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    $dependencies = parent::calculateDependencies();
+
+    foreach ($this->vocabularyStorage->loadMultiple(array_keys($this->options['vids'])) as $vocabulary) {
+      $dependencies[$vocabulary->getConfigDependencyKey()][] = $vocabulary->getConfigDependencyName();
+    }
+    return $dependencies;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/argument_validator/TermName.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\argument_validator;
+
+use Drupal\Core\Entity\EntityTypeBundleInfoInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\views\Attribute\ViewsArgumentValidator;
+use Drupal\views\Plugin\views\argument_validator\Entity;
+
+/**
+ * Validates whether a term name is a valid term argument.
+ */
+#[ViewsArgumentValidator(
+  id: 'taxonomy_term_name',
+  title: new TranslatableMarkup('Taxonomy term name'),
+  entity_type: 'taxonomy_term'
+)]
+class TermName extends Entity {
+
+  /**
+   * The taxonomy term storage.
+   *
+   * @var \Drupal\taxonomy\TermStorageInterface
+   */
+  protected $termStorage;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager, ?EntityTypeBundleInfoInterface $entity_type_bundle_info = NULL) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $entity_type_manager, $entity_type_bundle_info);
+    // Not handling exploding term names.
+    $this->multipleCapable = FALSE;
+    $this->termStorage = $entity_type_manager->getStorage('taxonomy_term');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+    $options['transform'] = ['default' => FALSE];
+
+    return $options;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    parent::buildOptionsForm($form, $form_state);
+
+    $form['transform'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Transform dashes in URL to spaces in term name filter values'),
+      '#default_value' => $this->options['transform'],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateArgument($argument) {
+    if ($this->options['transform']) {
+      $argument = str_replace('-', ' ', $argument);
+      $this->argument->argument = $argument;
+    }
+    // If bundles is set then restrict the loaded terms to the given bundles.
+    if (!empty($this->options['bundles'])) {
+      $terms = $this->termStorage->loadByProperties(['name' => $argument, 'vid' => $this->options['bundles']]);
+    }
+    else {
+      $terms = $this->termStorage->loadByProperties(['name' => $argument]);
+    }
+
+    // $terms are already bundle tested but we need to test access control.
+    foreach ($terms as $term) {
+      if ($this->validateEntity($term)) {
+        return TRUE;
+      }
+    }
+
+    return FALSE;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/field/TaxonomyIndexTid.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\field;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\views\Attribute\ViewsField;
+use Drupal\views\ViewExecutable;
+use Drupal\views\Plugin\views\display\DisplayPluginBase;
+use Drupal\views\Plugin\views\field\PrerenderList;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\taxonomy\VocabularyStorageInterface;
+
+/**
+ * Field handler to display all taxonomy terms of a node.
+ *
+ * @ingroup views_field_handlers
+ */
+#[ViewsField("taxonomy_index_tid")]
+class TaxonomyIndexTid extends PrerenderList {
+
+  /**
+   * The vocabulary storage.
+   *
+   * @var \Drupal\taxonomy\VocabularyStorageInterface
+   */
+  protected $vocabularyStorage;
+
+  /**
+   * Constructs a TaxonomyIndexTid object.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin ID for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\taxonomy\VocabularyStorageInterface $vocabulary_storage
+   *   The vocabulary storage.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, VocabularyStorageInterface $vocabulary_storage) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->vocabularyStorage = $vocabulary_storage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager')->getStorage('taxonomy_vocabulary')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function init(ViewExecutable $view, DisplayPluginBase $display, ?array &$options = NULL) {
+    parent::init($view, $display, $options);
+
+    // @todo Wouldn't it be possible to use $this->base_table and no if here?
+    if ($view->storage->get('base_table') == 'node_field_revision') {
+      $this->additional_fields['nid'] = ['table' => 'node_field_revision', 'field' => 'nid'];
+    }
+    else {
+      $this->additional_fields['nid'] = ['table' => 'node_field_data', 'field' => 'nid'];
+    }
+  }
+
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+
+    $options['link_to_taxonomy'] = ['default' => TRUE];
+    $options['limit'] = ['default' => FALSE];
+    $options['vids'] = ['default' => []];
+
+    return $options;
+  }
+
+  /**
+   * Provide "link to term" option.
+   */
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    $form['link_to_taxonomy'] = [
+      '#title' => $this->t('Link this field to its term page'),
+      '#type' => 'checkbox',
+      '#default_value' => !empty($this->options['link_to_taxonomy']),
+    ];
+
+    $form['limit'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Limit terms by vocabulary'),
+      '#default_value' => $this->options['limit'],
+    ];
+
+    $options = [];
+    $vocabularies = $this->vocabularyStorage->loadMultiple();
+    foreach ($vocabularies as $voc) {
+      $options[$voc->id()] = $voc->label();
+    }
+
+    $form['vids'] = [
+      '#type' => 'checkboxes',
+      '#title' => $this->t('Vocabularies'),
+      '#options' => $options,
+      '#default_value' => $this->options['vids'],
+      '#states' => [
+        'visible' => [
+          ':input[name="options[limit]"]' => ['checked' => TRUE],
+        ],
+      ],
+
+    ];
+
+    parent::buildOptionsForm($form, $form_state);
+  }
+
+  /**
+   * Add this term to the query.
+   */
+  public function query() {
+    $this->addAdditionalFields();
+  }
+
+  public function preRender(&$values) {
+    $vocabularies = $this->vocabularyStorage->loadMultiple();
+    $this->field_alias = $this->aliases['nid'];
+    $nids = [];
+    foreach ($values as $result) {
+      if (!empty($result->{$this->aliases['nid']})) {
+        $nids[] = $result->{$this->aliases['nid']};
+      }
+    }
+
+    if ($nids) {
+      $vids = array_filter($this->options['vids']);
+      if (empty($this->options['limit'])) {
+        $vids = [];
+      }
+      $result = \Drupal::entityTypeManager()->getStorage('taxonomy_term')->getNodeTerms($nids, $vids);
+
+      foreach ($result as $node_nid => $data) {
+        foreach ($data as $tid => $term) {
+          $this->items[$node_nid][$tid]['name'] = \Drupal::service('entity.repository')->getTranslationFromContext($term)->label();
+          $this->items[$node_nid][$tid]['tid'] = $tid;
+          $this->items[$node_nid][$tid]['vocabulary_vid'] = $term->bundle();
+          $this->items[$node_nid][$tid]['vocabulary'] = $vocabularies[$term->bundle()]->label();
+
+          if (!empty($this->options['link_to_taxonomy'])) {
+            $this->items[$node_nid][$tid]['make_link'] = TRUE;
+            $this->items[$node_nid][$tid]['path'] = 'taxonomy/term/' . $tid;
+          }
+        }
+      }
+    }
+  }
+
+  public function render_item($count, $item) {
+    return $item['name'];
+  }
+
+  protected function documentSelfTokens(&$tokens) {
+    $tokens['{{ ' . $this->options['id'] . '__tid' . ' }}'] = $this->t('The taxonomy term ID for the term.');
+    $tokens['{{ ' . $this->options['id'] . '__name' . ' }}'] = $this->t('The taxonomy term name for the term.');
+    $tokens['{{ ' . $this->options['id'] . '__vocabulary_vid' . ' }}'] = $this->t('The machine name for the vocabulary the term belongs to.');
+    $tokens['{{ ' . $this->options['id'] . '__vocabulary' . ' }}'] = $this->t('The name for the vocabulary the term belongs to.');
+  }
+
+  protected function addSelfTokens(&$tokens, $item) {
+    foreach (['tid', 'name', 'vocabulary_vid', 'vocabulary'] as $token) {
+      $tokens['{{ ' . $this->options['id'] . '__' . $token . ' }}'] = $item[$token] ?? '';
+    }
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/field/TermName.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\field;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\views\Attribute\ViewsField;
+use Drupal\views\Plugin\views\field\EntityField;
+use Drupal\views\ResultRow;
+
+/**
+ * Displays taxonomy term names and allows converting spaces to hyphens.
+ *
+ * @ingroup views_field_handlers
+ */
+#[ViewsField("term_name")]
+class TermName extends EntityField {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getItems(ResultRow $values) {
+    $items = parent::getItems($values);
+    if ($this->options['convert_spaces']) {
+      foreach ($items as &$item) {
+        // Replace spaces with hyphens.
+        $name = str_replace(' ', '-', $item['raw']->get('value')->getValue());
+        empty($this->options['settings']['link_to_entity']) ?
+          $item['rendered']['#context']['value'] = $name :
+          $item['rendered']['#title']['#context']['value'] = $name;
+      }
+    }
+    return $items;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+    $options['convert_spaces'] = ['default' => FALSE];
+    return $options;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    $form['convert_spaces'] = [
+      '#title' => $this->t('Convert spaces in term names to hyphens'),
+      '#type' => 'checkbox',
+      '#default_value' => !empty($this->options['convert_spaces']),
+    ];
+
+    parent::buildOptionsForm($form, $form_state);
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/filter/TaxonomyIndexTid.php

@@ -0,0 +1,420 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\filter;
+
+use Drupal\Core\Entity\Element\EntityAutocomplete;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\taxonomy\Entity\Term;
+use Drupal\taxonomy\TermStorageInterface;
+use Drupal\taxonomy\VocabularyStorageInterface;
+use Drupal\views\Attribute\ViewsFilter;
+use Drupal\views\ViewExecutable;
+use Drupal\views\Plugin\views\display\DisplayPluginBase;
+use Drupal\views\Plugin\views\filter\ManyToOne;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Filter by term id.
+ *
+ * @ingroup views_filter_handlers
+ */
+#[ViewsFilter("taxonomy_index_tid")]
+class TaxonomyIndexTid extends ManyToOne {
+
+  /**
+   * Stores the exposed input for this filter.
+   *
+   * @var array|null
+   */
+  // phpcs:ignore Drupal.NamingConventions.ValidVariableName.LowerCamelName
+  public $validated_exposed_input = NULL;
+
+  /**
+   * The vocabulary storage.
+   *
+   * @var \Drupal\taxonomy\VocabularyStorageInterface
+   */
+  protected $vocabularyStorage;
+
+  /**
+   * The term storage.
+   *
+   * @var \Drupal\taxonomy\TermStorageInterface
+   */
+  protected $termStorage;
+
+  /**
+   * The current user.
+   *
+   * @var \Drupal\Core\Session\AccountInterface
+   */
+  protected $currentUser;
+
+  /**
+   * Constructs a TaxonomyIndexTid object.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin ID for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\taxonomy\VocabularyStorageInterface $vocabulary_storage
+   *   The vocabulary storage.
+   * @param \Drupal\taxonomy\TermStorageInterface $term_storage
+   *   The term storage.
+   * @param \Drupal\Core\Session\AccountInterface $current_user
+   *   The current user.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, VocabularyStorageInterface $vocabulary_storage, TermStorageInterface $term_storage, AccountInterface $current_user) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->vocabularyStorage = $vocabulary_storage;
+    $this->termStorage = $term_storage;
+    $this->currentUser = $current_user;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager')->getStorage('taxonomy_vocabulary'),
+      $container->get('entity_type.manager')->getStorage('taxonomy_term'),
+      $container->get('current_user')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function init(ViewExecutable $view, DisplayPluginBase $display, ?array &$options = NULL) {
+    parent::init($view, $display, $options);
+
+    if (!empty($this->definition['vocabulary'])) {
+      $this->options['vid'] = $this->definition['vocabulary'];
+    }
+  }
+
+  public function hasExtraOptions() {
+    return TRUE;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getValueOptions() {
+    return $this->valueOptions;
+  }
+
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+
+    $options['type'] = ['default' => 'textfield'];
+    $options['limit'] = ['default' => TRUE];
+    $options['vid'] = ['default' => ''];
+    $options['hierarchy'] = ['default' => FALSE];
+    $options['error_message'] = ['default' => TRUE];
+
+    return $options;
+  }
+
+  public function buildExtraOptionsForm(&$form, FormStateInterface $form_state) {
+    $vocabularies = $this->vocabularyStorage->loadMultiple();
+    $options = [];
+    foreach ($vocabularies as $voc) {
+      $options[$voc->id()] = $voc->label();
+    }
+
+    if ($this->options['limit']) {
+      // We only do this when the form is displayed.
+      if (empty($this->options['vid'])) {
+        $first_vocabulary = reset($vocabularies);
+        $this->options['vid'] = $first_vocabulary->id();
+      }
+
+      if (empty($this->definition['vocabulary'])) {
+        $form['vid'] = [
+          '#type' => 'radios',
+          '#title' => $this->t('Vocabulary'),
+          '#options' => $options,
+          '#description' => $this->t('Select which vocabulary to show terms for in the regular options.'),
+          '#default_value' => $this->options['vid'],
+        ];
+      }
+    }
+
+    $form['type'] = [
+      '#type' => 'radios',
+      '#title' => $this->t('Selection type'),
+      '#options' => ['select' => $this->t('Dropdown'), 'textfield' => $this->t('Autocomplete')],
+      '#default_value' => $this->options['type'],
+    ];
+
+    $form['hierarchy'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Show hierarchy in dropdown'),
+      '#default_value' => !empty($this->options['hierarchy']),
+      '#states' => [
+        'visible' => [
+          ':input[name="options[type]"]' => ['value' => 'select'],
+        ],
+      ],
+    ];
+  }
+
+  protected function valueForm(&$form, FormStateInterface $form_state) {
+    $vocabulary = $this->vocabularyStorage->load($this->options['vid']);
+    if (empty($vocabulary) && $this->options['limit']) {
+      $form['markup'] = [
+        '#markup' => '<div class="js-form-item form-item">' . $this->t('An invalid vocabulary is selected. Change it in the options.') . '</div>',
+      ];
+      return;
+    }
+
+    if ($this->options['type'] == 'textfield') {
+      $terms = $this->value ? Term::loadMultiple(($this->value)) : [];
+      $form['value'] = [
+        '#title' => $this->options['limit'] ? $this->t('Select terms from vocabulary @voc', ['@voc' => $vocabulary->label()]) : $this->t('Select terms'),
+        '#type' => 'textfield',
+        '#default_value' => EntityAutocomplete::getEntityLabels($terms),
+      ];
+
+      if ($this->options['limit']) {
+        $form['value']['#type'] = 'entity_autocomplete';
+        $form['value']['#target_type'] = 'taxonomy_term';
+        $form['value']['#selection_settings']['target_bundles'] = [$vocabulary->id()];
+        $form['value']['#tags'] = TRUE;
+        $form['value']['#process_default_value'] = FALSE;
+      }
+    }
+    else {
+      if (!empty($this->options['hierarchy']) && $this->options['limit']) {
+        $tree = $this->termStorage->loadTree($vocabulary->id(), 0, NULL, TRUE);
+        $options = [];
+
+        if ($tree) {
+          foreach ($tree as $term) {
+            if (!$term->isPublished() && !$this->currentUser->hasPermission('administer taxonomy')) {
+              continue;
+            }
+            $choice = new \stdClass();
+            $choice->option = [$term->id() => str_repeat('-', $term->depth) . \Drupal::service('entity.repository')->getTranslationFromContext($term)->label()];
+            $options[] = $choice;
+          }
+        }
+      }
+      else {
+        $options = [];
+        $query = \Drupal::entityQuery('taxonomy_term')
+          ->accessCheck(TRUE)
+          // @todo Sorting on vocabulary properties -
+          //   https://www.drupal.org/node/1821274.
+          ->sort('weight')
+          ->sort('name')
+          ->addTag('taxonomy_term_access');
+        if (!$this->currentUser->hasPermission('administer taxonomy')) {
+          $query->condition('status', 1);
+        }
+        if ($this->options['limit']) {
+          $query->condition('vid', $vocabulary->id());
+        }
+        $terms = Term::loadMultiple($query->execute());
+        foreach ($terms as $term) {
+          $options[$term->id()] = \Drupal::service('entity.repository')->getTranslationFromContext($term)->label();
+        }
+      }
+
+      $default_value = (array) $this->value;
+
+      if ($exposed = $form_state->get('exposed')) {
+        $identifier = $this->options['expose']['identifier'];
+
+        if (!empty($this->options['expose']['reduce'])) {
+          $options = $this->reduceValueOptions($options);
+
+          if (!empty($this->options['expose']['multiple']) && empty($this->options['expose']['required'])) {
+            $default_value = [];
+          }
+        }
+
+        if (empty($this->options['expose']['multiple'])) {
+          if (empty($this->options['expose']['required']) && (empty($default_value) || !empty($this->options['expose']['reduce']))) {
+            $default_value = 'All';
+          }
+          elseif (empty($default_value)) {
+            $keys = array_keys($options);
+            $default_value = array_shift($keys);
+          }
+          // Due to #1464174 there is a chance that array('') was saved in the admin ui.
+          // Let's choose a safe default value.
+          elseif ($default_value == ['']) {
+            $default_value = 'All';
+          }
+          else {
+            $copy = $default_value;
+            $default_value = array_shift($copy);
+          }
+        }
+      }
+      $form['value'] = [
+        '#type' => 'select',
+        '#title' => $this->options['limit'] ? $this->t('Select terms from vocabulary @voc', ['@voc' => $vocabulary->label()]) : $this->t('Select terms'),
+        '#multiple' => TRUE,
+        '#options' => $options,
+        '#size' => min(9, count($options)),
+        '#default_value' => $default_value,
+      ];
+
+      $user_input = $form_state->getUserInput();
+      if ($exposed && isset($identifier) && !isset($user_input[$identifier])) {
+        $user_input[$identifier] = $default_value;
+        $form_state->setUserInput($user_input);
+      }
+    }
+
+    if (!$form_state->get('exposed')) {
+      // Retain the helper option
+      $this->helper->buildOptionsForm($form, $form_state);
+
+      // Show help text if not exposed to end users.
+      $form['value']['#description'] = $this->t('Leave blank for all. Otherwise, the first selected term will be the default instead of "Any".');
+    }
+  }
+
+  protected function valueValidate($form, FormStateInterface $form_state) {
+    // We only validate if they've chosen the text field style.
+    if ($this->options['type'] != 'textfield') {
+      return;
+    }
+
+    $tids = [];
+    if ($values = $form_state->getValue(['options', 'value'])) {
+      foreach ($values as $value) {
+        $tids[] = $value['target_id'];
+      }
+    }
+    $form_state->setValue(['options', 'value'], $tids);
+  }
+
+  public function acceptExposedInput($input) {
+    if (empty($this->options['exposed'])) {
+      return TRUE;
+    }
+    // We need to know the operator, which is normally set in
+    // \Drupal\views\Plugin\views\filter\FilterPluginBase::acceptExposedInput(),
+    // before we actually call the parent version of ourselves.
+    if (!empty($this->options['expose']['use_operator']) && !empty($this->options['expose']['operator_id']) && isset($input[$this->options['expose']['operator_id']])) {
+      $this->operator = $input[$this->options['expose']['operator_id']];
+    }
+
+    // If view is an attachment and is inheriting exposed filters, then assume
+    // exposed input has already been validated
+    if (!empty($this->view->is_attachment) && $this->view->display_handler->usesExposed()) {
+      $this->validated_exposed_input = (array) $this->view->exposed_raw_input[$this->options['expose']['identifier']];
+    }
+
+    // If we're checking for EMPTY or NOT, we don't need any input, and we can
+    // say that our input conditions are met by just having the right operator.
+    if ($this->operator == 'empty' || $this->operator == 'not empty') {
+      return TRUE;
+    }
+
+    // If it's non-required and there's no value don't bother filtering.
+    if (!$this->options['expose']['required'] && empty($this->validated_exposed_input)) {
+      return FALSE;
+    }
+
+    $rc = parent::acceptExposedInput($input);
+    if ($rc) {
+      // If we have previously validated input, override.
+      if (isset($this->validated_exposed_input)) {
+        $this->value = $this->validated_exposed_input;
+      }
+    }
+
+    return $rc;
+  }
+
+  public function validateExposed(&$form, FormStateInterface $form_state) {
+    if (empty($this->options['exposed'])) {
+      return;
+    }
+
+    $identifier = $this->options['expose']['identifier'];
+    $input = $form_state->getValue($identifier);
+
+    if ($this->options['is_grouped'] && isset($this->options['group_info']['group_items'][$input])) {
+      $this->validated_exposed_input = $this->options['group_info']['group_items'][$input]['value'];
+      return;
+    }
+
+    // We only validate if they've chosen the text field style.
+    if ($this->options['type'] != 'textfield') {
+      if ($form_state->getValue($identifier) != 'All') {
+        $this->validated_exposed_input = (array) $form_state->getValue($identifier);
+      }
+      return;
+    }
+
+    if (empty($this->options['expose']['identifier'])) {
+      return;
+    }
+
+    if ($values = $form_state->getValue($identifier)) {
+      foreach ($values as $value) {
+        $this->validated_exposed_input[] = $value['target_id'];
+      }
+    }
+  }
+
+  protected function valueSubmit($form, FormStateInterface $form_state) {
+    // Prevent array_filter from messing up our arrays in parent submit.
+  }
+
+  public function buildExposeForm(&$form, FormStateInterface $form_state) {
+    parent::buildExposeForm($form, $form_state);
+    if ($this->options['type'] != 'select') {
+      unset($form['expose']['reduce']);
+    }
+    $form['error_message'] = [
+      '#type' => 'checkbox',
+      '#title' => $this->t('Display error message'),
+      '#default_value' => !empty($this->options['error_message']),
+    ];
+  }
+
+  public function adminSummary() {
+    // Set up $this->valueOptions for the parent summary
+    $this->valueOptions = [];
+
+    if ($this->value) {
+      $this->value = array_filter($this->value);
+      $terms = Term::loadMultiple($this->value);
+      foreach ($terms as $term) {
+        $this->valueOptions[$term->id()] = \Drupal::service('entity.repository')->getTranslationFromContext($term)->label();
+      }
+    }
+    return parent::adminSummary();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    $dependencies = parent::calculateDependencies();
+
+    $vocabulary = $this->vocabularyStorage->load($this->options['vid']);
+    $dependencies[$vocabulary->getConfigDependencyKey()][] = $vocabulary->getConfigDependencyName();
+
+    foreach ($this->termStorage->loadMultiple($this->options['value']) as $term) {
+      $dependencies[$term->getConfigDependencyKey()][] = $term->getConfigDependencyName();
+    }
+
+    return $dependencies;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/filter/TaxonomyIndexTidDepth.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\filter;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\taxonomy\TaxonomyIndexDepthQueryTrait;
+use Drupal\views\Attribute\ViewsFilter;
+
+/**
+ * Filter handler for taxonomy terms with depth.
+ *
+ * This handler is actually part of the node table and has some restrictions,
+ * because it uses a subquery to find nodes with.
+ *
+ * @ingroup views_filter_handlers
+ */
+#[ViewsFilter("taxonomy_index_tid_depth")]
+class TaxonomyIndexTidDepth extends TaxonomyIndexTid {
+  use TaxonomyIndexDepthQueryTrait;
+
+  public function operatorOptions($which = 'title') {
+    return [
+      'or' => $this->t('Is one of'),
+    ];
+  }
+
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+
+    $options['depth'] = ['default' => 0];
+
+    return $options;
+  }
+
+  public function buildExtraOptionsForm(&$form, FormStateInterface $form_state) {
+    parent::buildExtraOptionsForm($form, $form_state);
+
+    $form['depth'] = [
+      '#type' => 'weight',
+      '#title' => $this->t('Depth'),
+      '#default_value' => $this->options['depth'],
+      '#description' => $this->t('The depth will match nodes tagged with terms in the hierarchy. For example, if you have the term "fruit" and a child term "apple", with a depth of 1 (or higher) then filtering for the term "fruit" will get nodes that are tagged with "apple" as well as "fruit". If negative, the reverse is true; searching for "apple" will also pick up nodes tagged with "fruit" if depth is -1 (or lower).'),
+    ];
+  }
+
+  public function query() {
+    // If no filter values are present, then do nothing.
+    if (count($this->value) == 0) {
+      return;
+    }
+    elseif (count($this->value) == 1) {
+      // Sometimes $this->value is an array with a single element so convert it.
+      if (is_array($this->value)) {
+        $this->value = current($this->value);
+      }
+    }
+
+    // The normal use of ensureMyTable() here breaks Views.
+    // So instead we trick the filter into using the alias of the base table.
+    // See https://www.drupal.org/node/271833.
+    // If a relationship is set, we must use the alias it provides.
+    if (!empty($this->relationship)) {
+      $this->tableAlias = $this->relationship;
+    }
+    // If no relationship, then use the alias of the base table.
+    else {
+      $this->tableAlias = $this->query->ensureTable($this->view->storage->get('base_table'));
+    }
+
+    $this->addSubQueryJoin($this->value);
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/relationship/NodeTermData.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\relationship;
+
+use Drupal\Core\Database\Database;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\taxonomy\VocabularyStorageInterface;
+use Drupal\views\Attribute\ViewsRelationship;
+use Drupal\views\Plugin\views\relationship\RelationshipPluginBase;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Relationship handler to return the taxonomy terms of nodes.
+ *
+ * @ingroup views_relationship_handlers
+ */
+#[ViewsRelationship("node_term_data")]
+class NodeTermData extends RelationshipPluginBase {
+
+  /**
+   * The vocabulary storage.
+   *
+   * @var \Drupal\taxonomy\VocabularyStorageInterface
+   */
+  protected $vocabularyStorage;
+
+  /**
+   * Constructs a NodeTermData object.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin ID for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\taxonomy\VocabularyStorageInterface $vocabulary_storage
+   *   The vocabulary storage.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, VocabularyStorageInterface $vocabulary_storage) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->vocabularyStorage = $vocabulary_storage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager')->getStorage('taxonomy_vocabulary')
+    );
+  }
+
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+    $options['vids'] = ['default' => []];
+    return $options;
+  }
+
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    $vocabularies = $this->vocabularyStorage->loadMultiple();
+    $options = [];
+    foreach ($vocabularies as $voc) {
+      $options[$voc->id()] = $voc->label();
+    }
+
+    $form['vids'] = [
+      '#type' => 'checkboxes',
+      '#title' => $this->t('Vocabularies'),
+      '#options' => $options,
+      '#default_value' => $this->options['vids'],
+      '#description' => $this->t('Choose which vocabularies you wish to relate. Remember that every term found will create a new record, so this relationship is best used on just one vocabulary that has only one term per node.'),
+    ];
+    parent::buildOptionsForm($form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitOptionsForm(&$form, FormStateInterface $form_state) {
+    // Transform the #type = checkboxes value to a numerically indexed array,
+    // because the config schema expects a sequence, not a mapping.
+    $vids = $form_state->getValue(['options', 'vids']);
+    $form_state->setValue(['options', 'vids'], array_values(array_filter($vids)));
+  }
+
+  /**
+   * Called to implement a relationship in a query.
+   */
+  public function query() {
+    $this->ensureMyTable();
+
+    $def = $this->definition;
+    $def['table'] = 'taxonomy_term_field_data';
+
+    if (!array_filter($this->options['vids'])) {
+      $taxonomy_index = $this->query->addTable('taxonomy_index', $this->relationship);
+      $def['left_table'] = $taxonomy_index;
+      $def['left_field'] = 'tid';
+      $def['field'] = 'tid';
+      $def['type'] = empty($this->options['required']) ? 'LEFT' : 'INNER';
+    }
+    else {
+      // If vocabularies are supplied join a subselect instead
+      $def['left_table'] = $this->tableAlias;
+      $def['left_field'] = 'nid';
+      $def['field'] = 'nid';
+      $def['type'] = empty($this->options['required']) ? 'LEFT' : 'INNER';
+      $def['adjusted'] = TRUE;
+
+      $query = Database::getConnection()->select('taxonomy_term_field_data', 'td');
+      $query->addJoin($def['type'], 'taxonomy_index', 'tn', '[tn].[tid] = [td].[tid]');
+      $query->condition('td.vid', array_filter($this->options['vids']), 'IN');
+      if (empty($this->query->options['disable_sql_rewrite'])) {
+        $query->addTag('taxonomy_term_access');
+      }
+      $query->fields('td');
+      $query->fields('tn', ['nid']);
+      $def['table formula'] = $query;
+    }
+
+    $join = \Drupal::service('plugin.manager.views.join')->createInstance('standard', $def);
+
+    // Use a short alias for this:
+    $alias = $def['table'] . '_' . $this->table;
+
+    $this->alias = $this->query->addRelationship($alias, $join, 'taxonomy_term_field_data', $this->relationship);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    $dependencies = parent::calculateDependencies();
+
+    foreach ($this->options['vids'] as $vocabulary_id) {
+      if ($vocabulary = $this->vocabularyStorage->load($vocabulary_id)) {
+        $dependencies[$vocabulary->getConfigDependencyKey()][] = $vocabulary->getConfigDependencyName();
+      }
+    }
+
+    return $dependencies;
+  }
+
+}

web/core/modules/taxonomy/src/Plugin/views/wizard/TaxonomyTerm.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\views\wizard;
+
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\views\Attribute\ViewsWizard;
+use Drupal\views\Plugin\views\wizard\WizardPluginBase;
+
+/**
+ * Tests creating taxonomy views with the wizard.
+ */
+#[ViewsWizard(
+  id: 'taxonomy_term',
+  title: new TranslatableMarkup('Taxonomy terms'),
+  base_table: 'taxonomy_term_field_data'
+)]
+class TaxonomyTerm extends WizardPluginBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function defaultDisplayOptions() {
+    $display_options = parent::defaultDisplayOptions();
+
+    // Add permission-based access control.
+    $display_options['access']['type'] = 'perm';
+    $display_options['access']['options']['perm'] = 'access content';
+
+    // Remove the default fields, since we are customizing them here.
+    unset($display_options['fields']);
+
+    /* Field: Taxonomy: Term */
+    $display_options['fields']['name']['id'] = 'name';
+    $display_options['fields']['name']['table'] = 'taxonomy_term_field_data';
+    $display_options['fields']['name']['field'] = 'name';
+    $display_options['fields']['name']['entity_type'] = 'taxonomy_term';
+    $display_options['fields']['name']['entity_field'] = 'name';
+    $display_options['fields']['name']['label'] = '';
+    $display_options['fields']['name']['alter']['alter_text'] = 0;
+    $display_options['fields']['name']['alter']['make_link'] = 0;
+    $display_options['fields']['name']['alter']['absolute'] = 0;
+    $display_options['fields']['name']['alter']['trim'] = 0;
+    $display_options['fields']['name']['alter']['word_boundary'] = 0;
+    $display_options['fields']['name']['alter']['ellipsis'] = 0;
+    $display_options['fields']['name']['alter']['strip_tags'] = 0;
+    $display_options['fields']['name']['alter']['html'] = 0;
+    $display_options['fields']['name']['hide_empty'] = 0;
+    $display_options['fields']['name']['empty_zero'] = 0;
+    $display_options['fields']['name']['type'] = 'string';
+    $display_options['fields']['name']['settings']['link_to_entity'] = 1;
+    $display_options['fields']['name']['plugin_id'] = 'term_name';
+
+    return $display_options;
+  }
+
+}