@amazeelabs/silverback-gutenberg 2.6.2

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

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\Directive;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql_directives\DirectiveInterface;
+
+/**
+ * @Directive(
+ *   id = "resolveEditorBlockAttribute",
+ *   description = "Retrieve an editor block attribute.",
+ *   arguments = {
+ *     "key" = "String!",
+ *     "plainText" = "Boolean"
+ *   }
+ * )
+ */
+class EditorBlockAttribute extends PluginBase implements DirectiveInterface {
+
+  public function buildResolver(ResolverBuilder $builder, array $arguments): ResolverInterface {
+    return $builder->produce('editor_block_attribute')
+      ->map('block', $builder->fromParent())
+      ->map('name', $builder->fromValue($arguments['key']))
+      ->map('plainText', $builder->fromValue($arguments['plainText'] ?? true));
+  }
+
+}

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

@@ -0,0 +1,21 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\Directive;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql_directives\DirectiveInterface;
+
+/**
+ * @Directive(
+ *   id = "resolveEditorBlockChildren"
+ * )
+ */
+class EditorBlockChildren extends PluginBase implements DirectiveInterface {
+
+  public function buildResolver(ResolverBuilder $builder, array $arguments): ResolverInterface {
+    return $builder->produce('editor_block_children')->map('block', $builder->fromParent());
+  }
+
+}

package/drupal/silverback_gutenberg/src/Plugin/GraphQL/Directive/EditorBlockMarkup.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\Directive;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql_directives\DirectiveInterface;
+
+/**
+ * @Directive(
+ *   id = "resolveEditorBlockMarkup"
+ * )
+ */
+class EditorBlockMarkup extends PluginBase implements DirectiveInterface {
+
+  public function buildResolver(ResolverBuilder $builder, array $arguments): ResolverInterface {
+    return $builder->produce('editor_block_html')->map('block', $builder->fromParent());
+  }
+
+}

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

@@ -0,0 +1,21 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\Directive;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql_directives\DirectiveInterface;
+
+/**
+ * @Directive(
+ *   id = "resolveEditorBlockMedia"
+ * )
+ */
+class EditorBlockMedia extends PluginBase implements DirectiveInterface {
+
+  public function buildResolver(ResolverBuilder $builder, array $arguments): ResolverInterface {
+    return $builder->produce('editor_block_media')->map('block', $builder->fromParent());
+  }
+
+}

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

@@ -0,0 +1,21 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\Directive;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql_directives\DirectiveInterface;
+
+/**
+ * @Directive(
+ *   id = "resolveEditorBlockType"
+ * )
+ */
+class EditorBlockType extends PluginBase implements DirectiveInterface {
+
+  public function buildResolver(ResolverBuilder $builder, array $arguments): ResolverInterface {
+    return $builder->produce('editor_block_type')->map('block', $builder->fromParent());
+  }
+
+}

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

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GraphQL\Directive;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+use Drupal\graphql_directives\DirectiveInterface;
+
+/**
+ * @Directive(
+ *   id = "resolveEditorBlocks",
+ *   description = "Parse a gutenberg document into block data.",
+ *   arguments = {
+ *     "path" = "String!",
+ *     "ignored" = "[String!]",
+ *     "aggregated" = "[String!]"
+ *   }
+ * )
+ */
+class EditorBlocks extends PluginBase implements DirectiveInterface {
+
+  public function buildResolver(ResolverBuilder $builder, array $arguments): ResolverInterface {
+    return $builder->produce('editor_blocks', [
+      'path' => $builder->fromValue($arguments['path']),
+      'entity' => $builder->fromParent(),
+      'type' => $builder->callback(
+        fn(EntityInterface $entity) => $entity->getTypedData()->getDataDefinition()->getDataType()
+      ),
+      'ignored' => $builder->fromValue($arguments['ignored'] ?? []),
+      'aggregated' => $builder->fromValue($arguments['aggregated'] ?? ['core/paragraph'])
+    ]);
+  }
+
+}

package/drupal/silverback_gutenberg/src/Plugin/GutenbergBlockMutator/MediaBlockMutator.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GutenbergBlockMutator;
+
+use Drupal\silverback_gutenberg\Attribute\GutenbergBlockMutator;
+use Drupal\silverback_gutenberg\BlockMutator\EntityBlockMutatorBase;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+
+#[GutenbergBlockMutator(
+  id: "media_block_mutator",
+  label: new TranslatableMarkup("Media IDs to UUIDs and viceversa."),
+)]
+class MediaBlockMutator extends EntityBlockMutatorBase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public bool $isMultiple = TRUE;
+
+  /**
+   * {@inheritDoc}
+   */
+  public string $gutenbergAttribute = 'mediaEntityIds';
+
+  /**
+   * {@inheritDoc}
+   */
+  public string $entityTypeId = 'media';
+
+}

package/drupal/silverback_gutenberg/src/Plugin/GutenbergBlockMutator/NodeBlockMutator.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GutenbergBlockMutator;
+
+use Drupal\silverback_gutenberg\Attribute\GutenbergBlockMutator;
+use Drupal\silverback_gutenberg\BlockMutator\EntityBlockMutatorBase;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+
+#[GutenbergBlockMutator(
+  id: "node_block_mutator",
+  label: new TranslatableMarkup("Node ID to UUID and viceversa."),
+)]
+class NodeBlockMutator extends EntityBlockMutatorBase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public string $gutenbergAttribute = 'nodeId';
+
+  /**
+   * {@inheritDoc}
+   */
+  public string $entityTypeId = 'node';
+
+}

package/drupal/silverback_gutenberg/src/Plugin/GutenbergBlockMutator/TermReferenceBlockMutator.php

@@ -0,0 +1,104 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\GutenbergBlockMutator;
+
+use Drupal\silverback_gutenberg\Attribute\GutenbergBlockMutator;
+use Drupal\silverback_gutenberg\BlockMutator\EntityBlockMutatorBase;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+
+#[GutenbergBlockMutator(
+  id: "term_reference_block_mutator",
+  label: new TranslatableMarkup("Term References to UUIDs and vice versa."),
+)]
+class TermReferenceBlockMutator extends EntityBlockMutatorBase {
+
+  /**
+   * {@inheritDoc}
+   */
+  public string $entityTypeId = 'taxonomy_term';
+
+  /**
+   * {@inheritDoc}
+   */
+  public function applies(array $block): bool {
+    // Skip the parent applies() check since we want to be more flexible
+    if (empty($block['attrs'])) {
+      return FALSE;
+    }
+
+    // Check if any attribute is registered as a term reference
+    foreach ($block['attrs'] as $attrName => $value) {
+      // Skip empty values
+      if (empty($value)) {
+        continue;
+      }
+
+      // Check if attribute is marked as a term reference
+      if ($this->isTermReferenceAttribute($attrName, $block, $value)) {
+        // Store the current attribute being processed
+        $this->gutenbergAttribute = $attrName;
+
+        // Auto-detect if multiple values
+        $this->isMultiple = is_array($value);
+
+        return TRUE;
+      }
+    }
+
+    return FALSE;
+  }
+
+  /**
+   * Determine if an attribute is a term reference.
+   *
+   * @param string $attrName
+   *   The attribute name to check.
+   * @param array $block
+   *   The block data.
+   * @param mixed $value
+   *   The attribute value.
+   *
+   * @return bool
+   *   TRUE if the attribute is a term reference.
+   */
+  protected function isTermReferenceAttribute(string $attrName, array $block, $value): bool {
+    if (preg_match('/(Term|Terms|TermId)$/i', $attrName)) {
+      // For single values
+      if (!is_array($value)) {
+        return $this->isValidTermIdentifier($value);
+      }
+      // For multiple values, check if all values are valid identifiers
+      elseif (is_array($value) && !empty($value)) {
+        return array_reduce($value, function ($carry, $item) {
+          return $carry && $this->isValidTermIdentifier($item);
+        }, TRUE);
+      }
+    }
+
+    // Add other checks here if needed
+    return FALSE;
+  }
+
+  /**
+   * Check if a value is a valid term identifier (numeric ID or UUID).
+   *
+   * @param mixed $value
+   *   The value to check.
+   *
+   * @return bool
+   *   TRUE if the value is a valid term identifier.
+   */
+  protected function isValidTermIdentifier($value): bool {
+    // Check if it's a numeric term ID
+    if (is_numeric($value)) {
+      return TRUE;
+    }
+
+    // Check if it's a UUID format
+    if (is_string($value) && preg_match('/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i', $value)) {
+      return TRUE;
+    }
+
+    return FALSE;
+  }
+}

package/drupal/silverback_gutenberg/src/Plugin/Linkit/Matcher/SilverbackMatcherTrait.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Linkit\Matcher;
+
+use Drupal\Component\Utility\Html;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\TranslatableInterface;
+use Drupal\linkit\Suggestion\SuggestionCollection;
+
+trait SilverbackMatcherTrait {
+
+  protected string $searchStringLowercase = '';
+
+  protected array $labelsToSortLowercase = [];
+
+  public function execute($string) {
+    $this->searchStringLowercase = mb_strtolower($string);
+
+    $suggestions = parent::execute($string)->getSuggestions();
+
+    // Sort suggestions by the position of the search string in the label.
+    uasort($this->labelsToSortLowercase, function ($a, $b) {
+      $aPos = strpos($a, $this->searchStringLowercase);
+      $bPos = strpos($b, $this->searchStringLowercase);
+      if ($aPos === $bPos) {
+        return 0;
+      }
+      return ($aPos < $bPos) ? -1 : 1;
+    });
+    // Reorder suggestions according to the sorted labels.
+    $suggestions = array_values(array_replace($this->labelsToSortLowercase, $suggestions));
+
+    $new = new SuggestionCollection();
+    foreach ($suggestions as $suggestion) {
+      $new->addSuggestion($suggestion);
+    }
+    return $new;
+  }
+
+  protected function buildLabel(EntityInterface $entity) {
+    // Entity query searches through all node translations, but the linkit node
+    // matcher prints only one translation (current language) in the
+    // suggestions. This can lead to a confusion because a suggestion can
+    // contain no input string.
+    // For such cases we redo the suggestion label to the following form:
+    // "<label in current language> (<translation that matches the input string>)"
+    // Additionally, we collect labels matching the input string to use for
+    // sorting later.
+
+    $label = (string) $entity->label();
+    if (str_contains(mb_strtolower($label), $this->searchStringLowercase)) {
+      $this->labelsToSortLowercase[] = mb_strtolower($label);
+      return Html::escape($label);
+    }
+    if ($entity instanceof TranslatableInterface && $entity->isTranslatable()) {
+      foreach ($entity->getTranslationLanguages() as $language) {
+        $translation = $entity->getTranslation($language->getId());
+        $translatedLabel = (string) $translation->label();
+        if (str_contains(mb_strtolower($translatedLabel), $this->searchStringLowercase)) {
+          $this->labelsToSortLowercase[] = mb_strtolower($translatedLabel);
+          return Html::escape("{$label} ({$translatedLabel})");
+        }
+      }
+    }
+    $this->labelsToSortLowercase[] = mb_strtolower($label);
+    return Html::escape($label);
+  }
+
+}

package/drupal/silverback_gutenberg/src/Plugin/Linkit/Matcher/SilverbackMediaMatcher.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Linkit\Matcher;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\linkit\Plugin\Linkit\Matcher\EntityMatcher;
+
+/**
+ * @Matcher(
+ *   id = "silverback:entity:media",
+ *   label = @Translation("Silverback: Media"),
+ *   target_entity = "media",
+ *   provider = "media"
+ * )
+ */
+class SilverbackMediaMatcher extends EntityMatcher {
+
+  use SilverbackMatcherTrait;
+
+  public function __construct(array $configuration, $plugin_id, $plugin_definition) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->targetType = 'media';
+  }
+
+  public function buildConfigurationForm(
+    array $form,
+    FormStateInterface $form_state
+  ) {
+    $form = parent::buildConfigurationForm(
+      $form,
+      $form_state
+    );
+
+    // Silverback Gutenberg does not take this setting into account anyway.
+    unset($form['substitution']);
+
+    return $form;
+  }
+
+  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
+    parent::submitConfigurationForm($form, $form_state);
+    // Because we unset the substitution fieldset in ::buildConfigurationForm(),
+    // we need to force it to 'canonical' because
+    // Drupal\silverback_gutenberg\Controller\LinkitAutocomplete() controller
+    // needs that info. If the substitution type is not set, then the
+    // autocomplete controller will just leave the /media/mid urls that are
+    // generated by the original linkit autocomplete service intact, which means
+    // they won't be replaced, on saving, with their corresponding /media/uuid
+    // counterparts.
+    $this->configuration['substitution_type'] = 'canonical';
+  }
+
+}

package/drupal/silverback_gutenberg/src/Plugin/Linkit/Matcher/SilverbackNodeMatcher.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Linkit\Matcher;
+
+use Drupal\linkit\Plugin\Linkit\Matcher\NodeMatcher;
+
+/**
+ * @Matcher(
+ *   id = "silverback:entity:node",
+ *   label = @Translation("Silverback: Content"),
+ *   target_entity = "node",
+ *   provider = "node"
+ * )
+ */
+class SilverbackNodeMatcher extends NodeMatcher {
+
+  use SilverbackMatcherTrait;
+
+}

package/drupal/silverback_gutenberg/src/Plugin/Validation/Constraint/Gutenberg.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Validation\Constraint;
+
+use Symfony\Component\Validator\Constraint;
+
+/**
+ * @Constraint(
+ *   id = "Gutenberg",
+ *   label = @Translation("Gutenberg", context = "Validation")
+ * )
+ */
+class Gutenberg extends Constraint {
+
+}

package/drupal/silverback_gutenberg/src/Plugin/Validation/Constraint/GutenbergValidator.php

@@ -0,0 +1,210 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Validation\Constraint;
+
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorInterface;
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleManager;
+use Drupal\Component\Plugin\Exception\PluginException;
+use Drupal\Component\Plugin\Exception\PluginNotFoundException;
+use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
+use Drupal\Core\Render\Markup;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use Drupal\gutenberg\Parser\BlockParser;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorManager;
+
+/**
+ * Validator class for the Gutenberg required field.
+ */
+class GutenbergValidator extends ConstraintValidator implements ContainerInjectionInterface {
+
+  use StringTranslationTrait;
+
+  protected $violations = [];
+
+  /**
+   * Flat representation of the blocks to track validation errors.
+   *
+   * @var array $blocksList
+   */
+  protected $blocksList = [];
+
+  /**
+   * Validator manager service plugin.
+   *
+   * @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorManager
+   */
+  protected $validatorManager;
+
+  /**
+   * Validator rule manager service plugin.
+   *
+   * @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleManager
+   */
+  protected $validatorRuleManager;
+
+  /**
+   * Constructs a GutenbergValidator object
+   * @param \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorManager $validator_manager
+   */
+  public function __construct(
+    GutenbergValidatorManager $validator_manager,
+    GutenbergValidatorRuleManager $validator_rule_manager
+  ) {
+    $this->validatorManager = $validator_manager;
+    $this->validatorRuleManager = $validator_rule_manager;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('plugin.manager.gutenberg_validator'),
+      $container->get('plugin.manager.gutenberg_validator_rule')
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validate($value, Constraint $constraint) {
+    // If the field is empty, we don't need to validate it.
+    // Delegate to Drupal.
+    if (empty($value->getValue())) {
+      return;
+    }
+    $content = $value->getValue()[0]['value'];
+    $parser = new BlockParser();
+    $blocks = $parser->parse($content);
+    $plugins = [];
+    foreach ($this->validatorManager->getDefinitions() as $definition) {
+      try {
+        $plugins[] = $this->validatorManager->createInstance($definition['id'], []);
+      } catch (PluginNotFoundException | PluginException $e) {
+        // Do nothing if the plugin could not be instantiated, although we
+        // should never get here, as before we just had a call to
+        // getDefinitions().
+      }
+    }
+
+    if (!empty($plugins)) {
+      $this->validateBlocks($blocks, $plugins);
+    }
+    // If we have any violations after running the blocks validation, we
+    // aggregate all of them in one message and fire a validation for the
+    // Gutenberg constraint.
+    if (!empty($this->violations)) {
+      $messages = [];
+      foreach ($this->violations as $violation) {
+        if (is_array($violation['message'])) {
+          $messages = array_merge($messages, $violation['message']);
+        } else {
+          $messages[] = $violation['message'];
+        }
+      }
+      $this->context->addViolation($this->t('Invalid content: <ul><li>@violations</li></ul>', ['@violations' => Markup::create(implode('</li><li>', $messages))]));
+    }
+  }
+
+  /**
+   * Validates a set of Gutenberg blocks (and their inner blocks) against a set
+   * of validator plugins.
+   *
+   * @param array $blocks
+   * @param array $plugins
+   */
+  public function validateBlocks(array &$blocks, array $plugins, array $breadcrumbs = []) {
+    // @todo: we have here a pretty big nesting level, would be nice to find a
+    //   solution to reduce it.
+    array_walk($blocks, function(&$block) use ($plugins, $breadcrumbs) {
+      array_walk($plugins, function(GutenbergValidatorInterface $plugin) use (&$block, $plugins, $breadcrumbs) {
+        // There are several recursion levels, so make sure to get a flat list
+        // of blocks, and mark the blocks that are already processed, so we don't
+        // end up with duplicates.
+        // This marker can then be reused to know which block instance
+        // is not valid.
+        if (empty($block['validator_id'])) {
+          $block['validator_id'] = uniqid();
+          $this->blocksList[$block['validator_id']] = $block['blockName'];
+        }
+
+        // Check if the block has inner blocks, and validate them as well.
+        if (!empty($block['innerBlocks'])) {
+          $breadcrumbs[] = $block['blockName'];
+          $this->validateBlocks($block['innerBlocks'], [$plugin], $breadcrumbs);
+        }
+        if (!$plugin->applies($block)) {
+          return;
+        }
+        $validatedFields = $plugin->validatedFields($block);
+        if (!empty($validatedFields)) {
+          array_walk($validatedFields, function($validatedField, $attrName) use ($block, $breadcrumbs) {
+            if (empty($validatedField['rules'])) {
+              return;
+            }
+            $attrValue = $block['attrs'][$attrName] ?? NULL;
+            array_walk($validatedField['rules'], function($validationRulePluginId) use ($attrValue, $attrName, $block, $validatedField, $breadcrumbs) {
+              try {
+                $rulePlugin = $this->validatorRuleManager->createInstance($validationRulePluginId);
+              } catch (PluginNotFoundException | PluginException $e) {
+                return;
+              }
+              $validationMessage = $rulePlugin->validate($attrValue, $validatedField['field_label'] ?? $attrName);
+              // If the returned value is the boolean TRUE, then it means the
+              // field is valid, so we can just return.
+              if ($validationMessage === TRUE) {
+                return;
+              }
+              $breadcrumbs[] = $block['blockName'];
+              $breadcrumbLabels = array_map(function($blockName) {
+                $blockNameParts = explode('/', $blockName);
+                return ucfirst(str_replace('-', ' ', end($blockNameParts)));
+              }, $breadcrumbs);
+              $breadcrumbsLabel = implode(' > ', $breadcrumbLabels);
+              $instanceId = $this->getInvalidInstanceId($block['validator_id'], $block['blockName']);
+              $message = '<span class="block-validation-error" data-block-instance="'. $instanceId .'" data-block-type="'. $block['blockName'] .'">';
+              $message .= $breadcrumbsLabel . ': ' . $validationMessage . '</span>';
+              $this->violations[] = [
+                'attribute' => $attrName,
+                'blockName' => $block['blockName'],
+                'rule' => $validationRulePluginId,
+                'message' =>  $message,
+              ];
+            });
+          });
+        }
+        // Last, call the validateContent method, in case there is a custom
+        // validation logic in the validator plugin itself.
+        $validateContent = $plugin->validateContent($block);
+        if (!empty($validateContent) && $validateContent['is_valid'] !== TRUE) {
+          $instanceId = $this->getInvalidInstanceId($block['validator_id'], $block['blockName']);
+          $message = '<span class="block-validation-error" data-block-instance="'. $instanceId .'" data-block-type="'. $block['blockName'] .'">';
+          $message .= $validateContent['message'] . '</span>';
+          $this->violations[] = [
+            'attribute' => 'block_content',
+            'blockName' => $block['blockName'],
+            'rule' => 'block_content',
+            'message' => $message,
+          ];
+        }
+      });
+    });
+  }
+
+  private function getInvalidInstanceId($validator_id, $block_name) {
+    $result = 0;
+    foreach($this->blocksList as $key => $value) {
+      if ($value === $block_name) {
+        $result++;
+      }
+      if ($key === $validator_id) {
+        break;
+      }
+    }
+    return $result;
+  }
+
+}