@amazeelabs/silverback-gutenberg 2.6.2

package/drupal/silverback_gutenberg/src/BlockMutator/BlockMutatorManager.php

@@ -0,0 +1,114 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\BlockMutator;
+
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Plugin\DefaultPluginManager;
+use Drupal\silverback_gutenberg\BlockMutator\BlockMutatorInterface;
+use Drupal\silverback_gutenberg\Attribute\GutenbergBlockMutator;
+
+/**
+ * The block mutator plugin manager class.
+ */
+class BlockMutatorManager extends DefaultPluginManager implements BlockMutatorManagerInterface {
+
+  /**
+   * Constructs a BlockMutatorManager object.
+   *
+   * @param \Traversable $namespaces
+   *   An object that implements \Traversable which contains the root paths
+   *   keyed by the corresponding namespace to look for plugin implementations.
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+   *   Cache backend instance to use.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler to invoke the alter hook with.
+   */
+  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler) {
+    parent::__construct(
+      'Plugin/GutenbergBlockMutator',
+      $namespaces,
+      $module_handler,
+      BlockMutatorInterface::class,
+      GutenbergBlockMutator::class,
+      // Keeping BC for deprecated Annotation
+      'Drupal\silverback_gutenberg\Annotation\GutenbergBlockMutator',
+    );
+    $this->alterInfo('gutenberg_block_mutator_info');
+    $this->setCacheBackend($cache_backend, 'gutenberg_block_mutator_info_plugins');
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function mutateExport(array &$blocks, array &$dependencies): void {
+    $this->mutate('export', $blocks, $dependencies);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function mutateImport(array &$blocks): void {
+    $this->mutate('import', $blocks);
+  }
+
+  /**
+   * Mutates a set of gutenberg blocks into a specicif direction
+   * (import/export).
+   *
+   * @param string $direction
+   *  The direction of the mutation. Can be "import" or "export".
+   * @param array $blocks
+   *  The gutenberg blocks being processed.
+   * @param array $dependencies
+   *  An array of dependencies for these blocks. Each key of the array should be
+   *  a uuid and the value should be the corresponding entity type. Example:
+   *  $dependencies['some-uuid'] = 'media';
+   */
+  protected function mutate(string $direction, array &$blocks, array &$dependencies = []): void {
+    if (empty($blocks)) {
+      return;
+    }
+    foreach ($this->getDefinitions() as $definition) {
+      /* @var \Drupal\silverback_gutenberg\BlockMutator\BlockMutatorInterface $mutatorPlugin */
+      $mutatorPlugin = $this->createInstance($definition['id']);
+      $this->doMutate($mutatorPlugin, $direction, $blocks, $dependencies);
+    }
+  }
+
+  /**
+   * Performs a mutation recursively on a set of gutenberg blocks, using a
+   * specific mutator plugin, into a specific direction (import / export).
+   *
+   * @param BlockMutatorInterface $mutatorPlugin
+   *  A block mutator plugin.
+   * @param string $direction
+   *  The direction of the mutation. Can be "import" or "export". If an invalid
+   *  string is sent, the "export" value is used.
+   * @param array $blocks
+   *  The gutenberg blocks being processed.
+   * @param array $dependencies
+   *  An array of dependencies for these blocks. Each key of the array should be
+   *  a uuid and the value should be the corresponding entity type. Example:
+   *  $dependencies['some-uuid'] = 'media';
+   */
+  protected function doMutate(BlockMutatorInterface $mutatorPlugin, string $direction, array &$blocks, array &$dependencies = []): void {
+    foreach ($blocks as &$block) {
+      if ($mutatorPlugin->applies($block)) {
+        switch ($direction) {
+          case 'import':
+            $mutatorPlugin->mutateImport($block);
+            break;
+          case 'export':
+          default:
+            $mutatorPlugin->mutateExport($block, $dependencies);
+            break;
+        }
+      }
+      if (!empty($block['innerBlocks'])) {
+        $this->doMutate($mutatorPlugin, $direction, $block['innerBlocks'], $dependencies);
+      }
+    }
+  }
+
+}

package/drupal/silverback_gutenberg/src/BlockMutator/BlockMutatorManagerInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\BlockMutator;
+
+/**
+ * Interface for the block mutator plugin manager.
+ */
+interface BlockMutatorManagerInterface {
+
+  /**
+   * Mutates the gutenberg blocks before they are exported by the default
+   * content module.
+   *
+   * @param array $blocks
+   *  The gutenberg blocks being processed.
+   * @param array $dependencies
+   *  An array of dependencies for these blocks. Each key of the array should be
+   *  a uuid and the value should be the corresponding entity type. Example:
+   *  $dependencies['some-uuid'] = 'media';
+   */
+  public function mutateExport(array &$blocks, array &$dependencies): void;
+
+  /**
+   * Mutates the gutenberg blocks before they get imported.
+   *
+   * @param array $blocks
+   *  The gutenberg blocks being processed.
+   */
+  public function mutateImport(array &$blocks): void;
+}

package/drupal/silverback_gutenberg/src/BlockMutator/EntityBlockMutatorBase.php

@@ -0,0 +1,189 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\BlockMutator;
+
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\EntityRepositoryInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Logger\LoggerChannelFactoryInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\Core\Plugin\PluginBase;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+abstract class EntityBlockMutatorBase extends PluginBase implements
+  BlockMutatorInterface,
+  ContainerFactoryPluginInterface {
+
+  /**
+   * The Gutenberg attribute id.
+   *
+   * @var string $gutenbergAttribute
+   */
+  public string $gutenbergAttribute;
+
+  /**
+   * Indicates if the Gutenberg attribute is a collection or a single value.
+   *
+   * @var bool $isMultiple
+   */
+  public bool $isMultiple = FALSE;
+
+  /**
+   * The Drupal entity type id.
+   *
+   * @var string $entityTypeId
+   */
+  public string $entityTypeId;
+
+  /**
+   * EntityBlockMutatorBase constructor.
+   *
+   * @param \Drupal\Core\Entity\EntityRepositoryInterface $repository
+   */
+  public function __construct(
+    array $configuration,
+          $plugin_id,
+          $plugin_definition,
+    private readonly EntityRepositoryInterface $entityRepository,
+    private readonly EntityTypeManagerInterface $entityTypeManager,
+    private readonly LoggerChannelFactoryInterface $loggerFactory,
+  ) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition): static {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity.repository'),
+      $container->get('entity_type.manager'),
+      $container->get('logger.factory'),
+    );
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function applies(array $block) : bool {
+    if (empty($this->gutenbergAttribute)) {
+      $this->loggerFactory->get('silverback_gutenberg')->warning(
+        $this->t('Block mutator attribute is not set for @class, ignoring.', [
+          '@class' => self::class,
+        ])
+      );
+      return FALSE;
+    }
+
+    if (empty($this->entityTypeId)) {
+      $this->loggerFactory->get('silverback_gutenberg')->warning(
+        $this->t('Block mutator attribute @attribute does not specifiy the entity type id for @class, ignoring.', [
+          '@attribute' => $this->gutenbergAttribute,
+          '@class' => self::class,
+        ])
+      );
+      return FALSE;
+    }
+
+    $entityTypes = $this->entityTypeManager->getDefinitions();
+    if (!array_key_exists($this->entityTypeId, $entityTypes)) {
+      throw new \Exception(
+        $this->t('Block mutator attribute @attribute does not have a valid entity type @entity_type_id for @class, ignoring.', [
+          '@attribute' => $this->gutenbergAttribute,
+          '@entity_type_id' => $this->entityTypeId,
+          '@class' => self::class,
+        ])
+      );
+    }
+
+    if (empty($block['attrs'][$this->gutenbergAttribute])) {
+      return FALSE;
+    }
+
+    if (
+      $this->isMultiple &&
+      !is_array($block['attrs'][$this->gutenbergAttribute])
+    ) {
+      throw new \Exception(
+        $this->t('Block mutator attribute @attribute is set to be multiple but is not iterable.', [
+          '@attribute' => $this->gutenbergAttribute,
+        ])
+      );
+    }
+
+    return TRUE;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function mutateExport(array &$block, array &$dependencies) : void {
+    if ($this->isMultiple) {
+      $block['attrs'][$this->gutenbergAttribute] = array_values(array_map(
+        function (ContentEntityInterface $entity) use (&$dependencies) {
+          $dependencies[$entity->uuid()] = $this->entityTypeId;
+          return $entity->uuid();
+        },
+        $this->entityRepository
+          ->getCanonicalMultiple($this->entityTypeId, $block['attrs'][$this->gutenbergAttribute])
+      ));
+    } else {
+      $entity = $this->entityRepository->getCanonical($this->entityTypeId, $block['attrs'][$this->gutenbergAttribute]);
+      if (!$entity instanceof ContentEntityInterface) {
+        $block['attrs'][$this->gutenbergAttribute] = '';
+        return;
+      }
+      $block['attrs'][$this->gutenbergAttribute] = $entity->uuid();
+      $dependencies[$entity->uuid()] = $this->entityTypeId;
+    }
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function mutateImport(array &$block) : void {
+    if ($this->isMultiple) {
+      $block['attrs'][$this->gutenbergAttribute] = array_map(
+        function (string $uuid) {
+          try {
+            $entity = $this->entityRepository->loadEntityByUuid($this->entityTypeId, $uuid);
+            return $entity->id();
+          }
+          catch (\Throwable $e) {
+            $this->loggerFactory->get('silverback_gutenberg')->warning(
+              $this->t(
+                '@class: Could not load @entity_type_id by uuid @uuid on import.', [
+                  '@class' => self::class,
+                  '@entity_type_id' => $this->entityTypeId,
+                  '@uuid' => $uuid,
+                ]
+              )
+            );
+            return $uuid;
+          }
+        },
+        $block['attrs'][$this->gutenbergAttribute]
+      );
+    } else {
+      try {
+        $entity = $this->entityRepository->loadEntityByUuid($this->entityTypeId, $block['attrs'][$this->gutenbergAttribute]);
+        $block['attrs'][$this->gutenbergAttribute] = $entity->id();
+      }
+      catch (\Throwable $e) {
+        $this->loggerFactory->get('silverback_gutenberg')->warning(
+          $this->t(
+            '@class: Could not load @entity_type_id by uuid @uuid on import.', [
+              '@class' => self::class,
+              '@entity_type_id' => $this->entityTypeId,
+              '@uuid' => $uuid,
+            ]
+          )
+        );
+      }
+    }
+  }
+
+}

package/drupal/silverback_gutenberg/src/BlockSerializer.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Drupal\silverback_gutenberg;
+
+/**
+ * Class BlockSerializer
+ *
+ * Copied from:
+ * https://core.trac.wordpress.org/browser/tags/5.3.1/src/wp-includes/blocks.php#L226
+ *
+ * @package Drupal\silverback_gutenberg
+ */
+class BlockSerializer {
+
+  public function serialize_blocks( $blocks ) {
+    return implode( '', array_map( fn ($block) => $this->serialize_block($block), $blocks ) );
+  }
+
+  protected function serialize_block( $block ) {
+    $block_content = '';
+
+    $index = 0;
+    foreach ( $block['innerContent'] as $chunk ) {
+      $block_content .= is_string( $chunk ) ? $chunk : $this->serialize_block( $block['innerBlocks'][ $index++ ] );
+    }
+
+    if ( ! is_array( $block['attrs'] ) ) {
+      $block['attrs'] = array();
+    }
+
+    return $this->get_comment_delimited_block_content(
+      $block['blockName'],
+      $block['attrs'],
+      $block_content
+    );
+  }
+
+  protected function get_comment_delimited_block_content($block_name = null, $block_attributes = null, $block_content = '') {
+    if ( is_null( $block_name ) ) {
+      return $block_content;
+    }
+
+    $serialized_block_name = $this->strip_core_block_namespace(
+      $block_name
+    );
+    $serialized_attributes = empty( $block_attributes ) ? '' : $this->serialize_block_attributes(
+        $block_attributes
+      ) . ' ';
+
+    if ( empty( $block_content ) ) {
+      return sprintf( '<!-- wp:%s %s/-->', $serialized_block_name, $serialized_attributes );
+    }
+
+    return sprintf(
+      '<!-- wp:%s %s-->%s<!-- /wp:%s -->',
+      $serialized_block_name,
+      $serialized_attributes,
+      $block_content,
+      $serialized_block_name
+    );
+  }
+
+  protected function strip_core_block_namespace( $block_name = null ) {
+    if ( is_string( $block_name ) && 0 === strpos( $block_name, 'core/' ) ) {
+      return substr( $block_name, 5 );
+    }
+
+    return $block_name;
+  }
+
+
+  protected function serialize_block_attributes( $block_attributes ) {
+    // TODO: Original wordpress serializer does not unescape slashes.
+    $encoded_attributes = json_encode( $block_attributes, JSON_UNESCAPED_SLASHES );
+    $encoded_attributes = preg_replace( '/--/', '\\u002d\\u002d', $encoded_attributes );
+    $encoded_attributes = preg_replace( '/</', '\\u003c', $encoded_attributes );
+    $encoded_attributes = preg_replace( '/>/', '\\u003e', $encoded_attributes );
+    $encoded_attributes = preg_replace( '/&/', '\\u0026', $encoded_attributes );
+    // Regex: /\\"/
+    $encoded_attributes = preg_replace( '/\\\\"/', '\\u0022', $encoded_attributes );
+
+    return $encoded_attributes;
+  }
+}

package/drupal/silverback_gutenberg/src/Controller/LinkitAutocomplete.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Controller;
+
+use Drupal\Component\Serialization\Json;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\gutenberg\Controller\SearchController;
+use Drupal\linkit\Controller\AutocompleteController;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Request;
+
+class LinkitAutocomplete extends SearchController {
+
+  public function search(Request $request): JsonResponse {
+    // As we're limited on changes we can make to the Gutenberg plugin, we're
+    // using the subtype to identify the linkit profile to use. With it defaulting
+    // to a linkit profile with id gutenberg. By default, it's set to the string "undefined", so we
+    // need to check for that as well.
+    $linkitProfileIdParam = $request->query->get('subtype');
+    $linkitProfileId = $linkitProfileIdParam !== "undefined" && $linkitProfileIdParam ? $linkitProfileIdParam : 'gutenberg';
+
+    if (
+      !\Drupal::moduleHandler()->moduleExists('linkit') ||
+      !($linkitProfile = \Drupal::entityTypeManager()->getStorage('linkit_profile')->load($linkitProfileId))
+    ) {
+      return parent::search($request);
+    }
+
+    $type = (string) $request->query->get('type');
+    if ($type !== 'post') {
+      return new JsonResponse([]);
+    }
+
+    $result = [];
+    $search = (string) $request->query->get('search');
+    $request->query->set('q', $search);
+    $linkitController = AutocompleteController::create(\Drupal::getContainer());
+    $response = $linkitController->autocomplete($request, $linkitProfile);
+    $rows = Json::decode($response->getContent())['suggestions'] ?? [];
+    /** @var \Drupal\linkit\SubstitutionManagerInterface $substitutionManager */
+    $substitutionManager = \Drupal::service('plugin.manager.linkit.substitution');
+    /** @var \Drupal\Core\Entity\EntityRepositoryInterface $entityRepository */
+    $entityRepository = \Drupal::service('entity.repository');
+    $langcode = \Drupal::languageManager()->getCurrentLanguage()->getId();
+    foreach ($rows as $row) {
+      $url = NULL;
+      $entity = NULL;
+      if (isset($row['entity_type_id'], $row['entity_uuid'])) {
+        if ($entity = $entityRepository->loadEntityByUuid($row['entity_type_id'], $row['entity_uuid'])) {
+          $entity = $entityRepository->getTranslationFromContext($entity, $langcode);
+          if (isset($row['substitution_id'])) {
+            $url = $substitutionManager
+              ->createInstance($row['substitution_id'])
+              ->getUrl($entity)
+              ->toString();
+          }
+        }
+      }
+      $result[] = [
+        'id' => $row['entity_uuid'],
+        'title' => $row['label'],
+        'type' => $entity
+          ? $this->getBundle($entity)
+          : ($row['entity_type_id'] ?? $row['description'] ?? NULL),
+        'url' => $url ?? $row['path'],
+      ];
+    }
+
+    return new JsonResponse($result);
+  }
+
+  protected function getBundle(EntityInterface $entity): string {
+    $entityType = $entity->getEntityType();
+    $bundle = NULL;
+    if ($entityType->hasKey('bundle')) {
+      $bundleKey = $entityType->getKey('bundle');
+      $bundle = $entity->get($bundleKey)->entity;
+    }
+    return $bundle
+      ? "{$entityType->getLabel()}: {$bundle->label()}"
+      : "{$entityType->getLabel()}";
+  }
+
+}

package/drupal/silverback_gutenberg/src/Directives.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Drupal\silverback_gutenberg;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\graphql\GraphQL\Resolver\ResolverInterface;
+use Drupal\graphql\GraphQL\ResolverBuilder;
+
+/**
+ * Custom directives for silverback compatibility.
+ */
+class Directives {
+
+  /**
+   * Extract gutenberg blocks from a page.
+   */
+  public static function editorBlocks(ResolverBuilder $builder) : ResolverInterface {
+    return $builder->produce('editor_blocks', [
+      'path' => $builder->fromArgument('path'),
+      'entity' => $builder->fromParent(),
+      'type' => $builder->compose(
+        $builder->fromParent(),
+        $builder->callback(
+          fn(EntityInterface $entity) =>
+            $entity->getTypedData()->getDataDefinition()->getDataType()
+      )),
+      'ignored' => $builder->fromArgument('ignored') ?? $builder->fromValue([]),
+      'aggregated' => $builder->fromArgument('aggregated') ?? $builder->fromValue(['core/paragraph']),
+    ]);
+  }
+
+  /**
+   * Retrieve a blocks inner-blocks.
+   */
+  public static function editorBlockChildren(ResolverBuilder $builder) : ResolverInterface {
+    return $builder->produce('editor_block_children')
+      ->map('block', $builder->fromParent());
+  }
+
+  /**
+   * Retrieve a blocks markup.
+   */
+  public static function editorBlockMarkup(ResolverBuilder $builder) : ResolverInterface {
+    return $builder->produce('editor_block_html')
+      ->map('block', $builder->fromParent());
+  }
+
+  /**
+   * Retrieve a blocks media entity.
+   */
+  public static function editorBlockMedia(ResolverBuilder $builder) : ResolverInterface {
+    return $builder->produce('editor_block_media')
+      ->map('block', $builder->fromParent());
+  }
+
+  /**
+   * Retrieve a blocks type.
+   */
+  public static function editorBlockType(ResolverBuilder $builder) : ResolverInterface {
+    return $builder->produce('editor_block_type')
+      ->map('block', $builder->fromParent());
+  }
+
+  /**
+   * Extract an attribute from a gutenberg block.
+   */
+  public static function editorBlockAttribute(ResolverBuilder $builder) : ResolverInterface {
+    return $builder->produce('editor_block_attribute')
+      ->map('block', $builder->fromParent())
+      ->map('name', $builder->fromArgument('key'))
+      ->map('plainText', $builder->fromArgument('plainText') ?? $builder->fromValue(TRUE));
+  }
+
+}

package/drupal/silverback_gutenberg/src/EditorBlocksProcessor.php

@@ -0,0 +1,53 @@
+<?php
+ namespace Drupal\silverback_gutenberg;
+
+class EditorBlocksProcessor {
+
+  static function aggregateParagraphs(array $blocks, ?array $types = ['core/paragraph']) {
+    $processed = [];
+    $content = [];
+    foreach ($blocks as $block) {
+      if (in_array($block['blockName'], $types)) {
+        $content[] = $block['innerHTML'];
+      }
+      else {
+        if (count($content)) {
+          $processed[] = [
+            'blockName' => 'core/paragraph',
+            'innerHTML' => implode('', $content),
+          ];
+          $content = [];
+        }
+        if ($block['innerBlocks']) {
+          $block['innerBlocks'] = static::aggregateParagraphs($block['innerBlocks'], $types);
+        }
+        $processed[] = $block;
+      }
+    }
+    if (count($content)) {
+      $processed[] = [
+        'blockName' => 'core/paragraph',
+        'innerHTML' => implode('', $content),
+      ];
+    }
+    return $processed;
+  }
+
+  static function processsIgnoredBlocks(array $blocks, ?array $ignored) {
+    if (empty($ignored)) {
+      return $blocks;
+    }
+    $processed = [];
+    foreach (array_filter($blocks, fn ($block) => !!$block['blockName']) as $block) {
+      if (in_array($block['blockName'], $ignored)) {
+        foreach ((static::processsIgnoredBlocks($block['innerBlocks'] ?? [], $ignored)) as $child) {
+          $processed[] = $child;
+        }
+      }
+      else {
+        $processed[] = $block;
+      }
+    }
+    return $processed;
+  }
+}

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergCardinalityValidatorInterface.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+interface GutenbergCardinalityValidatorInterface {
+
+  /**
+   * @var int
+   *   Value that can be used for the maximum.
+   */
+  const CARDINALITY_UNLIMITED = -1;
+
+  /**
+   * @var string
+   *  Specifies if the cardinality check is not limited to a given block type.
+   */
+  const CARDINALITY_ANY = 'any';
+
+}