@amazeelabs/silverback-gutenberg 2.6.2

package/drupal/silverback_gutenberg/src/Plugin/EntityUsage/Track/GutenbergLinkedContent.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\EntityUsage\Track;
+
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Entity\EntityFieldManagerInterface;
+use Drupal\Core\Entity\EntityRepositoryInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Field\FieldItemInterface;
+use Drupal\entity_usage\EntityUsageInterface;
+use Drupal\entity_usage\EntityUsageTrackBase;
+use Drupal\entity_usage\UrlToEntityInterface;
+use Drupal\silverback_gutenberg\LinkedContentExtractor;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Psr\Log\LoggerInterface;
+
+/**
+ * Tracks usage of linked content in Gutenberg editor.
+ *
+ * @EntityUsageTrack(
+ *   id = "gutenberg_linked_content",
+ *   label = @Translation("Linked content in Gutenberg"),
+ *   description = @Translation("Tracks linked content entities in Gutenberg."),
+ *   field_types = {"text", "text_long", "text_with_summary"},
+ * )
+ */
+class GutenbergLinkedContent extends EntityUsageTrackBase {
+  use GutenbergContentTrackTrait;
+
+  /* @var \Drupal\silverback_gutenberg\LinkedContentExtractor */
+  protected $linkedContentExtractor;
+
+  public function __construct(
+    array $configuration,
+    $plugin_id,
+    $plugin_definition,
+    EntityUsageInterface $usage_service,
+    EntityTypeManagerInterface $entity_type_manager,
+    EntityFieldManagerInterface $entity_field_manager,
+    ConfigFactoryInterface $config_factory,
+    EntityRepositoryInterface $entity_repository,
+    ?LoggerInterface $entityUsageLogger = NULL,
+    ?UrlToEntityInterface $urlToEntity = NULL,
+    ?array $always_track_base_fields = NULL,
+    ?LinkedContentExtractor $linked_content_extractor = NULL,
+  ) {
+    parent::__construct(
+      $configuration, $plugin_id,
+      $plugin_definition,
+      $usage_service,
+      $entity_type_manager,
+      $entity_field_manager,
+      $config_factory,
+      $entity_repository,
+      $entityUsageLogger,
+      $urlToEntity,
+      $always_track_base_fields
+    );
+    $this->linkedContentExtractor = $linked_content_extractor;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_usage.usage'),
+      $container->get('entity_type.manager'),
+      $container->get('entity_field.manager'),
+      $container->get('config.factory'),
+      $container->get('entity.repository'),
+      $container->get('logger.channel.entity_usage'),
+      $container->get(UrlToEntityInterface::class),
+      $container->getParameter('entity_usage')['always_track_base_fields'] ?? [],
+      $container->get('silverback_gutenberg.linked_content_extractor')
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function getTargetEntities(FieldItemInterface $item): array {
+    $itemValue = $item->getValue();
+    if (empty($itemValue['value'])) {
+      return [];
+    }
+    $references = $this->linkedContentExtractor->getTargetEntities($itemValue['value']);
+    if (empty($references)) {
+      return [];
+    }
+    return $this->convertReferencesToEntityUsageList($references);
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/EntityUsage/Track/GutenbergMediaEmbed.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\EntityUsage\Track;
+
+use Drupal\Core\Field\FieldItemInterface;
+use Drupal\entity_usage\EntityUsageTrackBase;
+use Drupal\gutenberg\Parser\BlockParser;
+
+/**
+ * Tracks usage of media entities in the Gutenberg editor.
+ *
+ * @EntityUsageTrack(
+ *   id = "gutenberg_media_embed",
+ *   label = @Translation("Media embed in Gutenberg"),
+ *   description = @Translation("Tracks embedded media entities in Gutenberg."),
+ *   field_types = {"text", "text_long", "text_with_summary"},
+ * )
+ */
+class GutenbergMediaEmbed extends EntityUsageTrackBase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public function getTargetEntities(FieldItemInterface $item): array {
+    $itemValue = $item->getValue();
+    if (empty($itemValue['value'])) {
+      return [];
+    }
+    $text = $itemValue['value'];
+    $blockParser = new BlockParser();
+    $blocks = $blockParser->parse($text);
+    $references = [];
+    $this->extractReferencesFromGutenbergBlocks($blocks, $references);
+    return array_unique($references);
+  }
+
+  /**
+   * Recursively extract all the media references from a set of gutenberg
+   * blocks.
+   *
+   * This method will just check if there is an attribute called mediaEntityIds
+   * for every block. If yes, then it will just add those ids to the list of
+   * media references. Then, if the current block has any inner blocks it will
+   * just call itself with the inner blocks as parameter.
+   *
+   * @param array $blocks
+   *  An array of gutenberg blocks.
+   * @param $references
+   *  An array with all the extracted references until the current call.
+   */
+  protected function extractReferencesFromGutenbergBlocks(array $blocks, array &$references) {
+    foreach ($blocks as $block) {
+      if (!empty($block['attrs']['mediaEntityIds'])) {
+        foreach ($block['attrs']['mediaEntityIds'] as $mediaEntityId) {
+          $references[] = 'media|' . $mediaEntityId;
+        }
+      }
+      if (!empty($block['innerBlocks'])) {
+        $this->extractReferencesFromGutenbergBlocks($block['innerBlocks'], $references);
+      }
+    }
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/EntityUsage/Track/GutenbergReferencedContent.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\EntityUsage\Track;
+
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Entity\EntityFieldManagerInterface;
+use Drupal\Core\Entity\EntityRepositoryInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Field\FieldItemInterface;
+use Drupal\entity_usage\EntityUsageInterface;
+use Drupal\entity_usage\EntityUsageTrackBase;
+use Drupal\entity_usage\UrlToEntityInterface;
+use Drupal\gutenberg\Parser\BlockParser;
+use Drupal\silverback_gutenberg\ReferencedContentExtractor;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Tracks usage of referenced content in Gutenberg editor.
+ *
+ * @EntityUsageTrack(
+ *   id = "gutenberg_referenced_content",
+ *   label = @Translation("Referenced content in Gutenberg"),
+ *   description = @Translation("Tracks referenced content entities in Gutenberg."),
+ *   field_types = {"text", "text_long", "text_with_summary"},
+ * )
+ */
+class GutenbergReferencedContent extends EntityUsageTrackBase {
+  use GutenbergContentTrackTrait;
+
+  /* @var \Drupal\silverback_gutenberg\ReferencedContentExtractor */
+  protected $referencedContentExtractor;
+
+  public function __construct(
+    array $configuration,
+    $plugin_id,
+    $plugin_definition,
+    EntityUsageInterface $usage_service,
+    EntityTypeManagerInterface $entity_type_manager,
+    EntityFieldManagerInterface $entity_field_manager,
+    ConfigFactoryInterface $config_factory,
+    EntityRepositoryInterface $entity_repository,
+    ?LoggerInterface $entityUsageLogger = NULL,
+    ?UrlToEntityInterface $urlToEntity = NULL,
+    ?array $always_track_base_fields = NULL,
+    ?ReferencedContentExtractor $referenced_content_extractor = NULL,
+  ) {
+    parent::__construct(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $usage_service,
+      $entity_type_manager,
+      $entity_field_manager,
+      $config_factory,
+      $entity_repository,
+      $entityUsageLogger,
+      $urlToEntity, $always_track_base_fields
+    );
+    $this->referencedContentExtractor = $referenced_content_extractor;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_usage.usage'),
+      $container->get('entity_type.manager'),
+      $container->get('entity_field.manager'),
+      $container->get('config.factory'),
+      $container->get('entity.repository'),
+      $container->get('logger.channel.entity_usage'),
+      $container->get(UrlToEntityInterface::class),
+      $container->getParameter('entity_usage')['always_track_base_fields'] ?? [],
+      $container->get('silverback_gutenberg.referenced_content_extractor')
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function getTargetEntities(FieldItemInterface $item): array {
+    $itemValue = $item->getValue();
+    if (empty($itemValue['value'])) {
+      return [];
+    }
+    $text = $itemValue['value'];
+    $blockParser = new BlockParser();
+    $blocks = $blockParser->parse($text);
+    $references = $this->referencedContentExtractor->getTargetEntities($blocks);
+
+    if (empty($references)) {
+      return [];
+    }
+    return $this->convertReferencesToEntityUsageList($references);
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/DataProducer/EditorBlockAttribute.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\DataProducer;
+
+use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+
+
+/**
+ * Resolves the attribute value from an editor block.
+ *
+ * @DataProducer(
+ *   id = "editor_block_attribute",
+ *   name = @Translation("Editor block attribute value"),
+ *   description = @Translation("Resolve an attribute value from an editor block."),
+ *   produces = @ContextDefinition("string",
+ *     label = @Translation("The attribute value")
+ *   ),
+ *   consumes = {
+ *     "block" = @ContextDefinition("any",
+ *       label = @Translation("The parsed editor block")
+ *     ),
+ *     "name" = @ContextDefinition("string",
+ *       label = @Translation("The attribute name.")
+ *     ),
+ *     "plainText" = @ContextDefinition("boolean",
+ *       label = @Translation("Whether to process as plain text.")
+ *     ),
+ *   }
+ * )
+ */
+class EditorBlockAttribute extends DataProducerPluginBase {
+  protected function processPlainText(string $text): string {
+    // Even if we do not use any HTML markup in a block text, Gutenberg still
+    // treats it as HTML, e.g. it turns "<" into "&lt;".
+    return html_entity_decode(trim($text));
+  }
+  public function resolve($block, $name, $plain_text = true) {
+    $field_value = $block['attrs'][$name] ?? NULL;
+    return $field_value && $plain_text ? $this->processPlainText($field_value) : $field_value;
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/DataProducer/EditorBlockChildren.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\DataProducer;
+
+use Drupal\graphql\GraphQL\Execution\FieldContext;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+use Drupal\silverback_gutenberg\EditorBlocksProcessor;
+
+
+/**
+ * Resolve any child blocks from an editor block.
+ *
+ * @DataProducer(
+ *   id = "editor_block_children",
+ *   name = @Translation("Editor block children"),
+ *   description = @Translation("Resolve children from an editor block."),
+ *   produces = @ContextDefinition("any",
+ *     label = @Translation("An array of child blocks")
+ *   ),
+ *   consumes = {
+ *     "block" = @ContextDefinition("any",
+ *       label = @Translation("The parsed editor block")
+ *     ),
+ *   }
+ * )
+ */
+class EditorBlockChildren extends DataProducerPluginBase {
+  public function resolve($block, FieldContext $fieldContext) {
+    $transientEditorBlocks = $fieldContext->getContextValue('ignored_editor_blocks');
+    return EditorBlocksProcessor::processsIgnoredBlocks($block['innerBlocks'] ?? [], $transientEditorBlocks);
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/DataProducer/EditorBlockHtml.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\DataProducer;
+
+use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+
+
+/**
+ * Resolves the HTML content inside an editor block.
+ *
+ * @DataProducer(
+ *   id = "editor_block_html",
+ *   name = @Translation("Editor block inner html"),
+ *   description = @Translation("Resolve html content from an editor block."),
+ *   produces = @ContextDefinition("string",
+ *     label = @Translation("The HTML content of the block")
+ *   ),
+ *   consumes = {
+ *     "block" = @ContextDefinition("any",
+ *       label = @Translation("The parsed editor block")
+ *     ),
+ *   }
+ * )
+ */
+class EditorBlockHtml extends DataProducerPluginBase {
+  public function resolve($block) {
+    return $block['innerHTML'];
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/DataProducer/EditorBlockMedia.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\DataProducer;
+
+use Drupal\Core\Cache\RefinableCacheableDependencyInterface;
+use Drupal\Core\Entity\EntityRepositoryInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\TranslatableInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\graphql\GraphQL\Buffers\EntityBuffer;
+use Drupal\graphql\GraphQL\Execution\FieldContext;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+use Drupal\layout_builder_fieldblock_test\ContextProvider\FakeViewModeContext;
+use Drupal\media\Entity\Media;
+use GraphQL\Deferred;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+
+/**
+ * Resolves a media entity attached to an editor block.
+ *
+ * @DataProducer(
+ *   id = "editor_block_media",
+ *   name = @Translation("Editor blockmedia"),
+ *   description = @Translation("Resolve the media item attached to an editor block."),
+ *   produces = @ContextDefinition("entity:media",
+ *     label = @Translation("The media item")
+ *   ),
+ *   consumes = {
+ *     "block" = @ContextDefinition("any",
+ *       label = @Translation("A parsed editor block")
+ *     )
+ *   }
+ * )
+ */
+class EditorBlockMedia extends DataProducerPluginBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The entity type manager service.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * The entity repository service.
+   *
+   * @var \Drupal\Core\Entity\EntityRepositoryInterface
+   */
+  protected $entityRepository;
+
+  /**
+   * The entity buffer service.
+   *
+   * @var \Drupal\graphql\GraphQL\Buffers\EntityBuffer
+   */
+  protected $entityBuffer;
+
+  /**
+   * {@inheritdoc}
+   *
+   * @codeCoverageIgnore
+   */
+  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'),
+      $container->get('entity.repository'),
+      $container->get('graphql.buffer.entity')
+    );
+  }
+
+  /**
+   * EntityLoad constructor.
+   *
+   * @param array $configuration
+   *   The plugin configuration array.
+   * @param string $pluginId
+   *   The plugin id.
+   * @param array $pluginDefinition
+   *   The plugin definition array.
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManager
+   *   The entity type manager service.
+   * @param \Drupal\Core\Entity\EntityRepositoryInterface $entityRepository
+   *   The entity repository service.
+   * @param \Drupal\graphql\GraphQL\Buffers\EntityBuffer $entityBuffer
+   *   The entity buffer service.
+   *
+   * @codeCoverageIgnore
+   */
+  public function __construct(
+    array $configuration,
+          $pluginId,
+    array $pluginDefinition,
+    EntityTypeManagerInterface $entityTypeManager,
+    EntityRepositoryInterface $entityRepository,
+    EntityBuffer $entityBuffer
+  ) {
+    parent::__construct($configuration, $pluginId, $pluginDefinition);
+    $this->entityTypeManager = $entityTypeManager;
+    $this->entityRepository = $entityRepository;
+    $this->entityBuffer = $entityBuffer;
+  }
+
+  public function resolve($block, FieldContext $context): ?Deferred {
+    $id = $block['attrs']['mediaEntityIds'][0] ?? NULL;
+
+    if (!$id) {
+      return new Deferred(function () { return NULL; });
+    }
+
+    $resolver = $this->entityBuffer->add('media', $id);
+    $language = $context->getContextValue('document_language');
+
+    return new Deferred(function () use ($language, $resolver, $context) {
+      if (!$entity = $resolver()) {
+        // If there is no entity with this id, add the list cache tags so that
+        // the cache entry is purged whenever a new entity of this type is
+        // saved.
+        $type = $this->entityTypeManager->getDefinition('media');
+        /** @var \Drupal\Core\Entity\EntityTypeInterface $type */
+        $tags = $type->getListCacheTags();
+        $context->addCacheTags($tags);
+        return NULL;
+      }
+
+      $context->addCacheableDependency($entity);
+      if (isset($bundles) && !in_array($entity->bundle(), $bundles)) {
+        // If the entity is not among the allowed bundles, don't return it.
+        return NULL;
+      }
+
+      // Get the correct translation.
+      if (
+        isset($language) &&
+        $language !== $entity->language()->getId() &&
+        $entity instanceof TranslatableInterface &&
+        $entity->hasTranslation($language)
+      ) {
+        $entity = $entity->getTranslation($language);
+        $entity->addCacheContexts(["static:language:{$language}"]);
+      }
+
+      // Check if the passed user (or current user if none is passed) has access
+      // to the entity, if not return NULL.
+      /** @var \Drupal\Core\Access\AccessResultInterface $accessResult */
+      $accessResult = $entity->access('view', NULL, TRUE);
+      $context->addCacheableDependency($accessResult);
+      if ($accessResult->isForbidden()) {
+        return NULL;
+      }
+
+      return $entity;
+    });
+  }
+
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/DataProducer/EditorBlockType.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\DataProducer;
+
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+
+
+/**
+ * Resolves the HTML content inside an editor block.
+ *
+ * @DataProducer(
+ *   id = "editor_block_type",
+ *   name = @Translation("Editor block type"),
+ *   description = @Translation("Resolve an editor blocks type."),
+ *   produces = @ContextDefinition("string",
+ *     label = @Translation("The blocks typename")
+ *   ),
+ *   consumes = {
+ *     "block" = @ContextDefinition("any",
+ *       label = @Translation("The parsed editor block")
+ *     ),
+ *   }
+ * )
+ */
+class EditorBlockType extends DataProducerPluginBase {
+  public function resolve($block) {
+    return $block['blockName'];
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/DataProducer/EditorBlocks.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\DataProducer;
+
+use Drupal\Core\Annotation\ContextDefinition;
+use Drupal\Core\Annotation\Translation;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Render\BubbleableMetadata;
+use Drupal\Core\Render\RenderContext;
+use Drupal\Core\TypedData\Exception\MissingDataException;
+use Drupal\Core\TypedData\TypedDataInterface;
+use Drupal\Core\TypedData\TypedDataTrait;
+use Drupal\graphql\GraphQL\Execution\FieldContext;
+use Drupal\graphql\Plugin\GraphQL\DataProducer\DataProducerPluginBase;
+use Drupal\gutenberg\Parser\BlockParser;
+use Drupal\silverback_gutenberg\EditorBlocksProcessor;
+use Drupal\silverback_gutenberg\LinkProcessor;
+use Drupal\typed_data\DataFetcherTrait;
+use Drupal\typed_data\Exception\InvalidArgumentException;
+use Drupal\typed_data\Exception\LogicException;
+
+
+/**
+ * Resolves a typed data value at a given property path and parses it to blocks.
+ *
+ * @DataProducer(
+ *   id = "editor_blocks",
+ *   name = @Translation("Editor blocks"),
+ *   description = @Translation("Resolve html content from a property path and parse it into blocks."),
+ *   produces = @ContextDefinition("any",
+ *     label = @Translation("List of Blocks")
+ *   ),
+ *   consumes = {
+ *     "path" = @ContextDefinition("string",
+ *       label = @Translation("Property path")
+ *     ),
+ *     "entity" = @ContextDefinition("any",
+ *       label = @Translation("Root value")
+ *     ),
+ *     "type" = @ContextDefinition("string",
+ *       label = @Translation("Root type"),
+ *       required = FALSE
+ *     ),
+ *     "ignored" = @ContextDefinition("any",
+ *       label = @Translation("Ignored block types"),
+ *       required = FALSE
+ *     ),
+ *     "aggregated" = @ContextDefinition("any",
+ *       label = @Translation("Aggregated into core/paragraph"),
+ *       required = FALSE
+ *     )
+ *   }
+ * )
+ */
+class EditorBlocks extends DataProducerPluginBase {
+  use TypedDataTrait;
+  use DataFetcherTrait;
+
+  public function resolve(
+    $path,
+    $entity,
+    $type,
+    $ignored,
+    $aggregated,
+    FieldContext $field
+  ) {
+    if (!$entity instanceof EntityInterface) {
+      throw new LogicException('Editor blocks can only be retrieved from Entities');
+    }
+    $field->setContextValue('document_language', $entity->language()->getId());
+    if (!($entity instanceof TypedDataInterface) && !empty($type)) {
+      $manager = $this->getTypedDataManager();
+      $definition = $manager->createDataDefinition($type);
+      $value = $manager->create($definition, $entity);
+    }
+
+    if (!($value instanceof TypedDataInterface)) {
+      throw new \BadMethodCallException('Could not derive typed data type.');
+    }
+
+    $bubbleable = new BubbleableMetadata();
+    $fetcher = $this->getDataFetcher();
+
+    $html = '';
+    try {
+      $html = $fetcher->fetchDataByPropertyPath($value, $path, $bubbleable)->getValue();
+    }
+    catch (MissingDataException $exception) {
+      // There is no data at the given path.
+    }
+    catch (InvalidArgumentException $exception) {
+      // The path is invalid for the source object.
+    }
+    finally {
+      $field->addCacheableDependency($bubbleable);
+    }
+
+    $linkProcessor = \Drupal::service(LinkProcessor::class);
+    $linkProcessor->resetCacheableMetadata();
+
+    $context = new RenderContext();
+    $result = \Drupal::service('renderer')->executeInRenderContext(
+      $context,
+      function () use ($entity, $field, $html, $linkProcessor) {
+        $parser = new BlockParser();
+        $html = $linkProcessor->processLinks($html, 'outbound', $entity->language());
+        return $parser->parse($html);
+      }
+    );
+    if (!$context->isEmpty()) {
+      $field->addCacheableDependency($context->pop());
+    }
+    $field->addCacheableDependency($linkProcessor->getCacheableMetadata());
+    $linkProcessor->resetCacheableMetadata();
+
+    $ignored = array_merge(['core/group'], $ignored ?? []);
+
+    $field->setContextValue('ignored_editor_blocks', $ignored);
+    $blocks = EditorBlocksProcessor::processsIgnoredBlocks($result, $ignored);
+    $blocks = EditorBlocksProcessor::aggregateParagraphs($blocks, $aggregated ?: ['core/paragraph']);
+
+    \Drupal::moduleHandler()->alter('editor_blocks', $blocks, $entity);
+
+    return $blocks;
+  }
+
+}