@amazeelabs/silverback-gutenberg 2.6.2

package/drupal/silverback_gutenberg/js/gutenberg-tweaks.js

@@ -0,0 +1,154 @@
+/* global drupalSettings, wp, jQuery */
+(function ($) {
+  drupalSettings.gutenberg._listeners.init.push(
+    // For all block types:
+    function () {
+      var blockTypes = wp.blocks.getBlockTypes();
+      for (var i = 0; i < blockTypes.length; i++) {
+        if (!blockTypes[i].supports) {
+          blockTypes[i].supports = {};
+        }
+        // Disable "Additional CSS class(es)" section.
+        blockTypes[i].supports.customClassName = false;
+        // Disable align options.
+        blockTypes[i].supports.align = false;
+      }
+    },
+
+    // Workaround for https://github.com/WordPress/gutenberg/issues/19815
+    function () {
+      var coreColumnsAllowed =
+        drupalSettings.editor.formats.gutenberg.editorSettings.allowedBlocks[
+          'core/columns'
+        ];
+      var coreImageAllowed =
+        drupalSettings.editor.formats.gutenberg.editorSettings.allowedBlocks[
+          'core/image'
+        ];
+      if (coreColumnsAllowed && !coreImageAllowed) {
+        var coreColumnsBlock = wp.blocks.getBlockType('core/columns');
+        // Remove core/image from the example.
+        coreColumnsBlock.example.innerBlocks[0].innerBlocks.splice(1, 1);
+      }
+    },
+    // Disable fullscreen mode.
+    function () {
+      const isFullscreenMode = wp.data
+        .select('core/edit-post')
+        .isFeatureActive('fullscreenMode');
+
+      if (isFullscreenMode) {
+        wp.data.dispatch('core/edit-post').toggleFeature('fullscreenMode');
+      }
+    },
+    // Remove most of the columns options.
+    function () {
+      var coreColumnsBlock = wp.blocks.getBlockType('core/columns');
+      coreColumnsBlock.supports.inserter = false;
+      coreColumnsBlock.supports.align = false;
+      coreColumnsBlock.supports.__experimentalColor = false;
+    },
+
+    // We never want some of the format options.
+    function () {
+      wp.richText.unregisterFormatType('core/image');
+      wp.richText.unregisterFormatType('core/text-color');
+    },
+
+    // We don't want table styles.
+    function () {
+      wp.blocks.unregisterBlockStyle('core/table', 'regular');
+      wp.blocks.unregisterBlockStyle('core/table', 'stripes');
+    },
+
+    // Workaround for https://www.drupal.org/project/gutenberg/issues/3261702
+    function () {
+      $('.gutenberg-full-editor').on('keydown', function (event) {
+        if (
+          event &&
+          (event.code === 'Enter' || event.code === 'Space') &&
+          event.target &&
+          $(event.target).hasClass('block-editor-link-control__search-submit')
+        ) {
+          var $chosenResult = $(event.target)
+            .closest('.block-editor-link-control__search-input-wrapper')
+            .find(
+              '.block-editor-link-control__search-results button[aria-selected="true"].is-entity',
+            );
+          if ($chosenResult.length) {
+            event.preventDefault();
+            $chosenResult.click();
+          }
+        }
+      });
+    },
+
+    // Validators: highlight the relevant blocks and scroll to the first error.
+    function () {
+      const { select, subscribe } = wp.data;
+
+      const closeListener = subscribe(() => {
+        const isReady = select('core/editor').__unstableIsEditorReady();
+        if (!isReady) {
+          // Editor not ready.
+          return;
+        }
+        // Close the listener as soon as we know we are ready to avoid an infinite loop.
+        closeListener();
+
+        // It seems that, even with this listener, we still need a timeout.
+        window.setTimeout(function () {
+          // Get all the validation errors based on the messages.
+          const validationErrors = {};
+          Array.from(
+            document.getElementsByClassName('block-validation-error'),
+          ).forEach(function (item) {
+            const blockType = item.getAttribute('data-block-type');
+            const blockInstance = parseInt(
+              item.getAttribute('data-block-instance'),
+            );
+            if (!(blockType in validationErrors)) {
+              validationErrors[blockType] = [];
+            }
+            validationErrors[blockType].push(blockInstance);
+          });
+
+          const blockTypeInstances = {};
+          let firstErrorBlockId = null;
+
+          // Append invalid class to the relevant blocks.
+          Array.from(document.getElementsByClassName('wp-block')).forEach(
+            function (item) {
+              const blockType = item.getAttribute('data-type');
+              if (!(blockType in blockTypeInstances)) {
+                blockTypeInstances[blockType] = [];
+              }
+              blockTypeInstances[blockType].push(item);
+              if (blockType in validationErrors) {
+                const blockId = item.getAttribute('data-block');
+                const blockInstanceId = blockTypeInstances[blockType].length;
+                if (validationErrors[blockType].includes(blockInstanceId)) {
+                  // Somehow, altering the item directly causes issues with
+                  // the block editor. So we use jQuery instead.
+                  $('div[data-block="' + blockId + '"]').addClass('not-valid');
+                  if (firstErrorBlockId === null) {
+                    firstErrorBlockId = blockId;
+                  }
+                }
+              }
+            },
+          );
+
+          // Scroll to the first error.
+          if (firstErrorBlockId !== null) {
+            document
+              .querySelector('div[data-block="' + firstErrorBlockId + '"]')
+              .scrollIntoView({
+                behavior: 'smooth',
+              });
+          }
+        }, 1000);
+      });
+    },
+  );
+})(jQuery);

package/drupal/silverback_gutenberg/silverback_gutenberg.api.php

@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * @deprecated Use hook_silverback_gutenberg_link_processor_block_attrs_alter
+ */
+function hook_silverback_gutenberg_link_processor_block_attributes_alter(
+  array &$attributes,
+  string $blockName,
+  callable $processUrlCallback
+) {
+  // Use hook_silverback_gutenberg_link_processor_block_attrs_alter() instead.
+}
+
+/**
+ * @param array $attributes
+ * @param array $context
+ *   Has the following keys:
+ *   - blockName: a string containing the block name
+ *   - processUrlCallback: a callback to process a single URL string
+ *       Callback signature: (string $url): string
+ *   - processLinksCallback: a callback to process links in an HTML string
+ *       Callback signature: (string $html): string
+ *   - direction: "inbound" or "outbound"
+ *   - language: LanguageInterface or null
+ */
+function hook_silverback_gutenberg_link_processor_block_attrs_alter(array &$attributes, array $context) {
+  if ($context['blockName'] === 'custom/my-links-block' && isset($attributes['urls'])) {
+    $attributes['urlsUnprocessed'] = [];
+    foreach ($attributes['urls'] as $key => $url) {
+      if ($context['direction'] === 'outbound') {
+        $attributes['urlsUnprocessed'][$key] = $url;
+      }
+      $attributes['urls'][$key] = $context['processUrlCallback']($url);
+    }
+  }
+  if ($context['blockName'] === 'custom/my-media-block' && isset($attributes['caption'])) {
+    $html = $attributes['caption'];
+    $attributes['caption'] = $context['processLinksCallback']($html);
+  }
+}
+
+function hook_silverback_gutenberg_link_processor_inbound_link_alter(
+  \DOMElement $link,
+  \Drupal\silverback_gutenberg\LinkProcessor $linkProcessor
+) {
+  // No idea.
+}
+
+function hook_silverback_gutenberg_link_processor_outbound_link_alter(
+  \DOMElement $link,
+  \Drupal\Core\Language\LanguageInterface $language,
+  \Drupal\silverback_gutenberg\LinkProcessor $linkProcessor
+) {
+  $url = $link->getAttribute('href');
+  if ($url && !$linkProcessor->linksToCurrentHost($url)) {
+    $link->setAttribute('target', '_blank');
+    $link->setAttribute('rel', 'noreferrer');
+  }
+}
+
+function hook_silverback_gutenberg_link_processor_inbound_url_alter(
+  string &$url,
+  \Drupal\silverback_gutenberg\LinkProcessor $linkProcessor
+) {
+  // No idea.
+}
+
+function hook_silverback_gutenberg_link_processor_outbound_url_alter(
+  string &$url,
+  \Drupal\Core\Language\LanguageInterface $language,
+  \Drupal\silverback_gutenberg\LinkProcessor $linkProcessor
+) {
+  if (preg_match('#^/media/([0-9]+)/edit$#', $url, $matches)) {
+    // For example, turn $url into a direct file link.
+  }
+}

package/drupal/silverback_gutenberg/silverback_gutenberg.info.yml

@@ -0,0 +1,8 @@
+name: Silverback Gutenberg
+type: module
+description: 'Adjusts Gutenberg for Amazee Labs needs.'
+package: Silverback
+core_version_requirement: ^8 || ^9 || ^10 || ^11
+
+dependencies:
+  - gutenberg:gutenberg (>=8.x-2.0-beta2)

package/drupal/silverback_gutenberg/silverback_gutenberg.libraries.yml

@@ -0,0 +1,14 @@
+tweaks:
+  js:
+    js/gutenberg-tweaks.js: {}
+  css:
+    theme:
+      css/gutenberg-tweaks.css: {}
+  dependencies:
+    - core/drupalSettings
+    - core/jquery
+
+base:
+  version: VERSION
+  js:
+    js/base.js: {}

package/drupal/silverback_gutenberg/silverback_gutenberg.module

@@ -0,0 +1,97 @@
+<?php
+
+use Drupal\Core\Asset\AttachedAssetsInterface;
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\node\NodeInterface;
+use Drupal\silverback_gutenberg\Utils;
+
+/**
+ * Implements hook_js_settings_alter().
+ */
+function silverback_gutenberg_js_settings_alter(array &$settings, AttachedAssetsInterface $assets) {
+  if (isset($settings['gutenberg'])) {
+    if (!isset($settings['gutenberg']['theme-support'])) {
+      $settings['gutenberg']['theme-support'] = [];
+    }
+    $settings['gutenberg']['theme-support'] = [
+
+        // Disable text colors.
+        'colors' => [],
+        'disableCustomColors' => TRUE,
+
+        // Disable typography.
+        'fontSizes' => [],
+        'disableCustomFontSizes' => TRUE,
+        '__experimentalDisableCustomLineHeight' => TRUE,
+        '__experimentalDisableDropCap' => TRUE,
+
+      ] + $settings['gutenberg']['theme-support'];
+  }
+}
+
+/**
+ * Implements hook_library_info_alter().
+ */
+function silverback_gutenberg_library_info_alter(&$libraries, $extension) {
+  if ($extension === 'gutenberg') {
+    $libraries['edit-node']['dependencies'][] = 'silverback_gutenberg/tweaks';
+  }
+}
+
+/**
+ * Implements hook_form_BASE_FORM_ID_alter().
+ */
+function silverback_gutenberg_form_node_form_alter(&$form, FormStateInterface $form_state) {
+  /** @var \Drupal\node\NodeInterface $node */
+  $node = $form_state->getFormObject()->getEntity();
+  foreach (Utils::getGutenbergFields($node) as $field) {
+      if (isset($form[$field]['widget'][0]) && is_array($form[$field]['widget'][0]) && is_string($form[$field]['widget'][0]['#default_value'])) {
+        $form[$field]['widget'][0]['#default_value'] =
+          Utils::linkProcessor()->processLinks(
+            $form[$field]['widget'][0]['#default_value'],
+            'outbound',
+            \Drupal::languageManager()->getLanguage(
+              $form['langcode']['widget'][0]['value']['#default_value']
+            )
+          );
+      }
+  }
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_presave().
+ */
+function silverback_gutenberg_node_presave(NodeInterface $node) {
+  foreach (Utils::getGutenbergFields($node) as $field) {
+    $field = $node->get($field);
+    if (is_string($field->value)) {
+      $field->value = Utils::linkProcessor()->processLinks(
+        $field->value,
+        'inbound'
+      );
+    }
+  }
+}
+
+/**
+ * Implements hook_silverback_gutenberg_link_processor_block_attrs_alter().
+ */
+function silverback_gutenberg_silverback_gutenberg_link_processor_block_attrs_alter(array &$attributes, array $context) {
+  if ($context['blockName'] === 'drupalmedia/drupal-media-entity' && isset($attributes['caption'])) {
+    $attributes['caption'] = $context['processLinksCallback']($attributes['caption']);
+  }
+}
+
+/**
+ * Implements hook_entity_bundle_field_info_alter().
+ */
+function silverback_gutenberg_entity_bundle_field_info_alter(&$fields, EntityTypeInterface $entity_type, $bundle) {
+  if ($entity_type->id() === 'node') {
+    $gutenberg_config = \Drupal::config('gutenberg.settings');
+    $is_gutenberg_enabled = $gutenberg_config->get($bundle . '_enable_full');
+    if (isset($fields['body']) && $is_gutenberg_enabled) {
+      $fields['body']->addConstraint('Gutenberg', []);
+    }
+  }
+}

package/drupal/silverback_gutenberg/silverback_gutenberg.services.yml

@@ -0,0 +1,29 @@
+services:
+  Drupal\silverback_gutenberg\Routing\RouteSubscriber:
+    class: Drupal\silverback_gutenberg\Routing\RouteSubscriber
+    tags:
+      - { name: event_subscriber }
+  Drupal\silverback_gutenberg\LinkProcessor:
+    class: Drupal\silverback_gutenberg\LinkProcessor
+    arguments:
+      [
+        '@path_alias.manager',
+        '@config.factory',
+        '@request_stack',
+        '@module_handler',
+        '@entity.repository',
+        '@entity_type.manager',
+      ]
+  plugin.manager.gutenberg_validator:
+    class: Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorManager
+    parent: default_plugin_manager
+  plugin.manager.gutenberg_validator_rule:
+    class: Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleManager
+    parent: default_plugin_manager
+  silverback_gutenberg.linked_content_extractor:
+    class: \Drupal\silverback_gutenberg\LinkedContentExtractor
+  silverback_gutenberg.referenced_content_extractor:
+    class: \Drupal\silverback_gutenberg\ReferencedContentExtractor
+  plugin.manager.block_mutator:
+    class: Drupal\silverback_gutenberg\BlockMutator\BlockMutatorManager
+    parent: default_plugin_manager

package/drupal/silverback_gutenberg/src/Annotation/GutenbergBlockMutator.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Annotation;
+
+use Drupal\Component\Annotation\Plugin;
+
+/**
+ * @Annotation
+ * 
+ * @deprecated
+ */
+class GutenbergBlockMutator extends Plugin {
+
+  /**
+   * The block mutator plugin ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * The human-readable name of the block mutator plugin.
+   *
+   * @ingroup plugin_translatable
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   */
+  public $label;
+
+  /**
+   * The description of the block mutator plugin.
+   *
+   * @ingroup plugin_translatable
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   */
+  public $description;
+
+}

package/drupal/silverback_gutenberg/src/Annotation/GutenbergValidator.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Annotation;
+
+use Drupal\Component\Annotation\Plugin;
+
+/**
+ * @Annotation
+ */
+class GutenbergValidator extends Plugin {
+
+  /**
+   * The validator plugin ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * The human-readable name of the validator plugin.
+   *
+   * @ingroup plugin_translatable
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   */
+  public $label;
+
+  /**
+   * The description of the validator plugin.
+   *
+   * @ingroup plugin_translatable
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   */
+  public $description;
+
+}

package/drupal/silverback_gutenberg/src/Annotation/GutenbergValidatorRule.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Annotation;
+
+use Drupal\Component\Annotation\Plugin;
+
+/**
+ * @Annotation
+ */
+class GutenbergValidatorRule extends Plugin {
+
+  /**
+   * The validator plugin ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * The human-readable name of the validator plugin.
+   *
+   * @ingroup plugin_translatable
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   */
+  public $label;
+
+  /**
+   * The description of the validator plugin.
+   *
+   * @ingroup plugin_translatable
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   */
+  public $description;
+
+}

package/drupal/silverback_gutenberg/src/Attribute/GutenbergBlockMutator.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\silverback_gutenberg\Attribute;
+
+use Drupal\Component\Plugin\Attribute\Plugin;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+class GutenbergBlockMutator extends Plugin {
+
+  /**
+   * Constructs a GutenbergBlockMutator attribute.
+   *
+   * @param string $id
+   *   The plugin ID.
+   * @param \Drupal\Core\StringTranslation\TranslatableMarkup|null $label
+   *   (optional) The human-readable name of the mutator.
+   * @param \Drupal\Core\StringTranslation\TranslatableMarkup|null $description
+   *   (optional) A short description of the mutator.
+   */
+  public function __construct(
+    public readonly string $id,
+    public readonly ?TranslatableMarkup $label = NULL,
+    public readonly ?TranslatableMarkup $description = NULL,
+  ) {}
+
+}

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

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\BlockMutator;
+
+use Drupal\Core\Plugin\PluginBase;
+
+/**
+ * Base class for the block mutator plugins. This does basically nothing on
+ * import / export, but it can be used by mutator classes that provide only one
+ * operation (import or export).
+ */
+abstract class BlockMutatorBase extends PluginBase implements BlockMutatorInterface {
+
+  /**
+   * {@inheritDoc}
+   */
+  public function mutateExport(array &$block, array &$dependencies): void {}
+
+  /**
+   * {@inheritDoc}
+   */
+  public function mutateImport(array &$block): void {}
+
+}

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

@@ -0,0 +1,41 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\BlockMutator;
+
+/**
+ * Interface for block mutator plugins.
+ */
+interface BlockMutatorInterface {
+
+  /**
+   * Checks if the $block sent as parameter should be mutated.
+   *
+   * @param array $block
+   *  The gutenberg block being processed.
+   * @return bool
+   */
+  public function applies(array $block): bool;
+
+  /**
+   * Mutates the gutenberg block before it is exported by the default content
+   * module.
+   *
+   * @param array $block
+   *  The gutenberg block being processed. The changes should be done directly
+   *  on the block.
+   * @param array $dependencies
+   *  An array of dependencies for this block. 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 &$block, array &$dependencies): void;
+
+  /**
+   * Mutates the gutenberg block before it gets imported.
+   *
+   * @param array $block
+   *  The gutenberg block being processed. The changes should be done directly
+   *  on the block.
+   */
+  public function mutateImport(array &$block): void;
+}