├── LICENSE
├── composer.json
└── src
    ├── Block
        ├── Block.php
        ├── DelimiterBlock.php
        ├── EmbedBlock.php
        ├── HeaderBlock.php
        ├── Image
        │   └── File.php
        ├── ImageBlock.php
        ├── ListBlock.php
        ├── ParagraphBlock.php
        ├── QuoteBlock.php
        └── RawBlock.php
    ├── BlockRenderer
        ├── BlockRendererInterface.php
        ├── DelimiterBlockRenderer.php
        ├── EmbedBlockRenderer.php
        ├── GenericBlockRenderer.php
        ├── HeaderBlockRenderer.php
        ├── ImageBlockRenderer.php
        ├── ListBlockRenderer.php
        ├── ParagraphBlockRenderer.php
        ├── QuoteBlockRenderer.php
        └── RawBlockRenderer.php
    ├── Exception
        ├── InvalidDataException.php
        ├── InvalidJsonException.php
        ├── MappingErrorException.php
        ├── OptionsResolverException.php
        ├── ParserExceptionInterface.php
        ├── RendererExceptionInterface.php
        ├── ReservedKeyException.php
        ├── UndefinedOptionException.php
        ├── UnmappedTypeException.php
        └── UnsupportedBlockException.php
    ├── Parser
        ├── Parser.php
        ├── ParserInterface.php
        └── ParserResult.php
    └── Renderer
        ├── Renderer.php
        └── RendererInterface.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2025 Setono
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "setono/editorjs-php",
 3 |     "description": "PHP library for handling data from the EditorJS",
 4 |     "license": "MIT",
 5 |     "type": "library",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Joachim Løvgaard",
 9 |             "email": "joachim@loevgaard.dk"
10 |         }
11 |     ],
12 |     "require": {
13 |         "php": ">=8.1",
14 |         "azjezz/psl": "^2.9 || ^3.2",
15 |         "cuyz/valinor": "^1.9",
16 |         "psr/log": "^1.1 || ^2.0 || ^3.0",
17 |         "setono/html-element": "^1.0",
18 |         "symfony/options-resolver": "^4.4 || ^5.4 || ^6.0 || ^7.0"
19 |     },
20 |     "require-dev": {
21 |         "infection/infection": "^0.28.1",
22 |         "php-standard-library/psalm-plugin": "^2.3",
23 |         "phpunit/phpunit": "^9.6",
24 |         "psalm/plugin-phpunit": "^0.19.5",
25 |         "setono/code-quality-pack": "^2.6",
26 |         "shipmonk/composer-dependency-analyser": "^1.8.2"
27 |     },
28 |     "prefer-stable": true,
29 |     "autoload": {
30 |         "psr-4": {
31 |             "Setono\\EditorJS\\": "src/"
32 |         }
33 |     },
34 |     "autoload-dev": {
35 |         "psr-4": {
36 |             "Setono\\EditorJS\\": "tests/"
37 |         }
38 |     },
39 |     "config": {
40 |         "allow-plugins": {
41 |             "dealerdirect/phpcodesniffer-composer-installer": false,
42 |             "ergebnis/composer-normalize": true,
43 |             "infection/extension-installer": true
44 |         },
45 |         "sort-packages": true
46 |     },
47 |     "scripts": {
48 |         "analyse": "psalm",
49 |         "check-style": "ecs check",
50 |         "fix-style": "ecs check --fix",
51 |         "phpunit": "phpunit",
52 |         "rector": "rector"
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Block/Block.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | /**
 8 |  * All blocks must inherit from this class
 9 |  */
10 | abstract class Block
11 | {
12 |     public function __construct(
13 |         /**
14 |          * This is the unique id of the block, typically it looks something like this: GGt5HAoo0w
15 |          */
16 |         public readonly string $id,
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Block/DelimiterBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class DelimiterBlock extends Block
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Block/EmbedBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class EmbedBlock extends Block
 8 | {
 9 |     public function __construct(
10 |         string $id,
11 |         public readonly string $service,
12 |         public readonly string $source,
13 |         public readonly string $embed,
14 |         public readonly int $width,
15 |         public readonly int $height,
16 |         public readonly ?string $caption = null,
17 |     ) {
18 |         parent::__construct($id);
19 |     }
20 | 
21 |     /**
22 |      * A helper method for the CSS attribute 'aspect-ratio'
23 |      */
24 |     public function getAspectRatio(): string
25 |     {
26 |         return sprintf('%d / %d', $this->width, $this->height);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Block/HeaderBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class HeaderBlock extends Block
 8 | {
 9 |     public function __construct(
10 |         string $id,
11 |         public readonly string $text,
12 |         /**
13 |          * This is the header level, i.e. 1 for h1, 2 for h2, etc.
14 |          */
15 |         public readonly int $level,
16 |     ) {
17 |         parent::__construct($id);
18 |     }
19 | 
20 |     /**
21 |      * This is a helper method to get the HTML tag for the header
22 |      */
23 |     public function getTag(): string
24 |     {
25 |         return sprintf('h%d', $this->level);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Block/Image/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block\Image;
 6 | 
 7 | // todo right now it doesn't support the extra data you can set on the File object (see https://github.com/editor-js/image#providing-custom-uploading-methods)
 8 | final class File
 9 | {
10 |     public function __construct(public readonly string $url)
11 |     {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Block/ImageBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | use Setono\EditorJS\Block\Image\File;
 8 | 
 9 | final class ImageBlock extends Block
10 | {
11 |     public function __construct(
12 |         string $id,
13 |         public readonly File $file,
14 |         public readonly string $caption,
15 |         public readonly bool $withBorder,
16 |         public readonly bool $withBackground,
17 |         public readonly bool $stretched,
18 |     ) {
19 |         parent::__construct($id);
20 |     }
21 | 
22 |     /**
23 |      * Returns true if the caption is not empty, i.e. $this->caption !== ''
24 |      *
25 |      * @psalm-assert-if-true non-empty-string $this->caption
26 |      */
27 |     public function hasCaption(): bool
28 |     {
29 |         return '' !== $this->caption;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Block/ListBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class ListBlock extends Block
 8 | {
 9 |     public const STYLE_ORDERED = 'ordered';
10 | 
11 |     public const STYLE_UNORDERED = 'unordered';
12 | 
13 |     /**
14 |      * This is a helper property containing the html tag for the list (i.e. ol/ul)
15 |      *
16 |      * @var 'ol'|'ul'
17 |      */
18 |     public string $tag;
19 | 
20 |     public function __construct(
21 |         string $id,
22 |         /**
23 |          * @var self::STYLE_* $style
24 |          */
25 |         public readonly string $style,
26 |         /**
27 |          * @var list<string> $items
28 |          */
29 |         public readonly array $items,
30 |     ) {
31 |         parent::__construct($id);
32 | 
33 |         $this->tag = $style === self::STYLE_ORDERED ? 'ol' : 'ul';
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Block/ParagraphBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class ParagraphBlock extends Block
 8 | {
 9 |     public function __construct(string $id, public readonly string $text)
10 |     {
11 |         parent::__construct($id);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Block/QuoteBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class QuoteBlock extends Block
 8 | {
 9 |     public function __construct(
10 |         string $id,
11 |         public readonly string $text,
12 |         public readonly string $caption,
13 |         /**
14 |          * @var 'left'|'center'
15 |          */
16 |         public readonly string $alignment,
17 |     ) {
18 |         parent::__construct($id);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Block/RawBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Block;
 6 | 
 7 | final class RawBlock extends Block
 8 | {
 9 |     public function __construct(string $id, public readonly string $html)
10 |     {
11 |         parent::__construct($id);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/BlockRendererInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Exception\RendererExceptionInterface;
 9 | use Setono\HtmlElement\HtmlElement;
10 | 
11 | /**
12 |  * Implement this interface for each of your blocks
13 |  */
14 | interface BlockRendererInterface
15 | {
16 |     /**
17 |      * @throws RendererExceptionInterface
18 |      */
19 |     public function render(Block $block): HtmlElement|string;
20 | 
21 |     public function supports(Block $block): bool;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/DelimiterBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\DelimiterBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | use Symfony\Component\OptionsResolver\OptionsResolver;
12 | 
13 | final class DelimiterBlockRenderer extends GenericBlockRenderer
14 | {
15 |     public function render(Block $block): HtmlElement
16 |     {
17 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
18 | 
19 |         return (new HtmlElement($this->getOption('tag')))->withClass($this->getClassOption('class'));
20 |     }
21 | 
22 |     /**
23 |      * @psalm-assert-if-true DelimiterBlock $block
24 |      */
25 |     public function supports(Block $block): bool
26 |     {
27 |         return $block instanceof DelimiterBlock;
28 |     }
29 | 
30 |     protected function configureOptions(OptionsResolver $optionsResolver): void
31 |     {
32 |         parent::configureOptions($optionsResolver);
33 | 
34 |         $optionsResolver->setDefault('tag', 'hr')
35 |             ->setAllowedTypes('tag', 'string')
36 |         ;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/EmbedBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\EmbedBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | use Symfony\Component\OptionsResolver\OptionsResolver;
12 | 
13 | final class EmbedBlockRenderer extends GenericBlockRenderer
14 | {
15 |     /**
16 |      * @param EmbedBlock|Block $block
17 |      */
18 |     public function render(Block $block): HtmlElement
19 |     {
20 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
21 | 
22 |         return HtmlElement::div(
23 |             HtmlElement::iframe()
24 |                 ->withAttribute('width', $block->width)
25 |                 ->withAttribute('height', $block->height)
26 |                 ->withAttribute('src', $block->embed)
27 |                 ->withAttribute('frameborder', 0)
28 |                 ->withAttribute('allow', 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture')
29 |                 ->withAttribute('allowfullscreen')
30 |                 ->withClass($this->getClassOption('class')),
31 |         )->withClass($this->getClassOption('containerClass'));
32 |     }
33 | 
34 |     protected function configureOptions(OptionsResolver $optionsResolver): void
35 |     {
36 |         parent::configureOptions($optionsResolver);
37 | 
38 |         $optionsResolver->setDefault('containerClass', 'container-embed')
39 |             ->setAllowedTypes('containerClass', 'string')
40 |         ;
41 |     }
42 | 
43 |     /**
44 |      * @psalm-assert-if-true EmbedBlock $block
45 |      */
46 |     public function supports(Block $block): bool
47 |     {
48 |         return $block instanceof EmbedBlock;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/GenericBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Exception\OptionsResolverException;
 8 | use Setono\EditorJS\Exception\UndefinedOptionException;
 9 | use Symfony\Component\OptionsResolver\Exception\ExceptionInterface;
10 | use Symfony\Component\OptionsResolver\OptionsResolver;
11 | 
12 | abstract class GenericBlockRenderer implements BlockRendererInterface
13 | {
14 |     private array $options;
15 | 
16 |     public function __construct(array $options = [])
17 |     {
18 |         $resolver = new OptionsResolver();
19 |         $this->configureOptions($resolver);
20 | 
21 |         try {
22 |             $this->options = $resolver->resolve($options);
23 |         } catch (ExceptionInterface $e) {
24 |             throw new OptionsResolverException($e, $this);
25 |         }
26 |     }
27 | 
28 |     protected function configureOptions(OptionsResolver $optionsResolver): void
29 |     {
30 |         $optionsResolver->setDefault('class', '')
31 |             ->setAllowedTypes('class', 'string')
32 |             ->setDefault('classPrefix', 'editorjs-')
33 |             ->setAllowedTypes('classPrefix', 'string')
34 |         ;
35 |     }
36 | 
37 |     /**
38 |      * @psalm-assert-if-true mixed $this->options[$option]
39 |      */
40 |     protected function hasOption(string $option): bool
41 |     {
42 |         return isset($this->options[$option]);
43 |     }
44 | 
45 |     protected function getOption(string $option): mixed
46 |     {
47 |         if (!$this->hasOption($option)) {
48 |             throw new UndefinedOptionException($option, array_keys($this->options));
49 |         }
50 | 
51 |         return $this->options[$option];
52 |     }
53 | 
54 |     /**
55 |      * This is a helper method to allow you to get an option value which MUST be a (css) class option.
56 |      * This method will then prepend the class prefix to the option and return it
57 |      */
58 |     protected function getClassOption(string $option): string
59 |     {
60 |         /** @var mixed $option */
61 |         $option = $this->getOption($option);
62 |         if (!is_string($option) || '' === $option) {
63 |             return '';
64 |         }
65 | 
66 |         /** @psalm-suppress MixedArgument */
67 |         return sprintf('%s%s', $this->getOption('classPrefix'), $option);
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/HeaderBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\HeaderBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | 
12 | final class HeaderBlockRenderer extends GenericBlockRenderer
13 | {
14 |     /**
15 |      * @param HeaderBlock|Block $block
16 |      */
17 |     public function render(Block $block): HtmlElement
18 |     {
19 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
20 | 
21 |         return (new HtmlElement(sprintf('h%d', $block->level), $block->text))
22 |             ->withClass($this->getClassOption('class'))
23 |         ;
24 |     }
25 | 
26 |     /**
27 |      * @psalm-assert-if-true HeaderBlock $block
28 |      */
29 |     public function supports(Block $block): bool
30 |     {
31 |         return $block instanceof HeaderBlock;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/ImageBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\ImageBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | use Symfony\Component\OptionsResolver\OptionsResolver;
12 | 
13 | final class ImageBlockRenderer extends GenericBlockRenderer
14 | {
15 |     /**
16 |      * @param ImageBlock|Block $block
17 |      */
18 |     public function render(Block $block): HtmlElement
19 |     {
20 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
21 | 
22 |         $container = HtmlElement::div()
23 |             ->withClass($this->getClassOption('containerClass'))
24 |             ->withClass($this->getClassOption('withBorderClass'))
25 |             ->withClass($this->getClassOption('withBackgroundClass'))
26 |             ->withClass($this->getClassOption('stretchedClass'))
27 |         ;
28 | 
29 |         $image = HtmlElement::img()
30 |             ->withClass($this->getClassOption('imageClass'))
31 |             ->withAttribute('src', $block->file->url)
32 |         ;
33 | 
34 |         if ($block->hasCaption()) {
35 |             $image = $image->withAttribute('alt', $block->caption);
36 |         }
37 | 
38 |         $container = $container->append(
39 |             HtmlElement::div($image)->withClass($this->getClassOption('imageContainerClass')),
40 |         );
41 | 
42 |         if ($block->hasCaption()) {
43 |             $container = $container->append(HtmlElement::div($block->caption)
44 |                 ->withClass($this->getClassOption('captionContainerClass')))
45 |             ;
46 |         }
47 | 
48 |         return $container;
49 |     }
50 | 
51 |     protected function configureOptions(OptionsResolver $optionsResolver): void
52 |     {
53 |         parent::configureOptions($optionsResolver);
54 | 
55 |         $optionsResolver->setDefault('containerClass', 'container-image')
56 |             ->setAllowedTypes('containerClass', 'string')
57 |             ->setDefault('imageContainerClass', 'image')
58 |             ->setAllowedTypes('imageContainerClass', 'string')
59 |             ->setDefault('captionContainerClass', 'caption')
60 |             ->setAllowedTypes('captionContainerClass', 'string')
61 |             ->setDefault('imageClass', '')
62 |             ->setAllowedTypes('imageClass', 'string')
63 |             ->setDefault('withBorderClass', 'with-border')
64 |             ->setAllowedTypes('withBorderClass', 'string')
65 |             ->setDefault('withBackgroundClass', 'with-background')
66 |             ->setAllowedTypes('withBackgroundClass', 'string')
67 |             ->setDefault('stretchedClass', 'stretched')
68 |             ->setAllowedTypes('stretchedClass', 'string')
69 |         ;
70 |     }
71 | 
72 |     /**
73 |      * @psalm-assert-if-true ImageBlock $block
74 |      */
75 |     public function supports(Block $block): bool
76 |     {
77 |         return $block instanceof ImageBlock;
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/ListBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\ListBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | use Symfony\Component\OptionsResolver\OptionsResolver;
12 | 
13 | final class ListBlockRenderer extends GenericBlockRenderer
14 | {
15 |     /**
16 |      * @param ListBlock|Block $block
17 |      */
18 |     public function render(Block $block): HtmlElement
19 |     {
20 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
21 | 
22 |         return (new HtmlElement($block->tag, ...array_map(
23 |             fn (string $item) => HtmlElement::li($item)->withClass($this->getClassOption('itemClass')),
24 |             $block->items,
25 |         )))
26 |             ->withClass($this->getClassOption('class'))
27 |         ;
28 |     }
29 | 
30 |     protected function configureOptions(OptionsResolver $optionsResolver): void
31 |     {
32 |         parent::configureOptions($optionsResolver);
33 | 
34 |         $optionsResolver->setDefault('itemClass', '')
35 |             ->setAllowedTypes('itemClass', 'string')
36 |         ;
37 |     }
38 | 
39 |     /**
40 |      * @psalm-assert-if-true ListBlock $block
41 |      */
42 |     public function supports(Block $block): bool
43 |     {
44 |         return $block instanceof ListBlock;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/ParagraphBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\ParagraphBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | 
12 | final class ParagraphBlockRenderer extends GenericBlockRenderer
13 | {
14 |     /**
15 |      * @param ParagraphBlock|Block $block
16 |      */
17 |     public function render(Block $block): HtmlElement
18 |     {
19 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
20 | 
21 |         return HtmlElement::p($block->text)->withClass($this->getClassOption('class'));
22 |     }
23 | 
24 |     /**
25 |      * @psalm-assert-if-true ParagraphBlock $block
26 |      */
27 |     public function supports(Block $block): bool
28 |     {
29 |         return $block instanceof ParagraphBlock;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/QuoteBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\QuoteBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | 
12 | final class QuoteBlockRenderer extends GenericBlockRenderer
13 | {
14 |     /**
15 |      * @param QuoteBlock|Block $block
16 |      */
17 |     public function render(Block $block): HtmlElement
18 |     {
19 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
20 | 
21 |         $element = HtmlElement::blockquote($block->text)
22 |             ->withClass($this->getClassOption('class'))
23 |         ;
24 | 
25 |         if ('' !== $block->caption) {
26 |             return $element->append(HtmlElement::cite($block->caption));
27 |         }
28 | 
29 |         return $element;
30 |     }
31 | 
32 |     /**
33 |      * @psalm-assert-if-true QuoteBlock $block
34 |      */
35 |     public function supports(Block $block): bool
36 |     {
37 |         return $block instanceof QuoteBlock;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/BlockRenderer/RawBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\BlockRenderer;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\Block\RawBlock;
 9 | use Setono\EditorJS\Exception\UnsupportedBlockException;
10 | use Setono\HtmlElement\HtmlElement;
11 | 
12 | final class RawBlockRenderer extends GenericBlockRenderer
13 | {
14 |     /**
15 |      * @param RawBlock|Block $block
16 |      */
17 |     public function render(Block $block): HtmlElement
18 |     {
19 |         UnsupportedBlockException::assert($this->supports($block), $block, $this);
20 | 
21 |         return HtmlElement::div($block->html)->withClass($this->getClassOption('class'));
22 |     }
23 | 
24 |     /**
25 |      * @psalm-assert-if-true RawBlock $block
26 |      */
27 |     public function supports(Block $block): bool
28 |     {
29 |         return $block instanceof RawBlock;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidDataException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | use Psl\Type\Exception\AssertException;
 8 | 
 9 | final class InvalidDataException extends \RuntimeException implements ParserExceptionInterface
10 | {
11 |     public function __construct(public readonly string $json, AssertException $e)
12 |     {
13 |         parent::__construct(sprintf(
14 |             'You have an error in the supplied data. The error was: %s. You can access the supplied JSON in the %s property',
15 |             $e->getMessage(),
16 |             self::class . '::$json',
17 |         ), 0, $e);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidJsonException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | final class InvalidJsonException extends \InvalidArgumentException implements ParserExceptionInterface
 8 | {
 9 |     public function __construct(public readonly string $json, \JsonException $e)
10 |     {
11 |         parent::__construct(sprintf(
12 |             'You have an error in your JSON. The error was: %s. You can access the supplied JSON in the %s property',
13 |             $e->getMessage(),
14 |             self::class . '::$json',
15 |         ), 0, $e);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exception/MappingErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | use CuyZ\Valinor\Mapper\MappingError;
 8 | use CuyZ\Valinor\Mapper\Tree\Message\Messages;
 9 | use Setono\EditorJS\Block\Block;
10 | 
11 | final class MappingErrorException extends \InvalidArgumentException implements ParserExceptionInterface
12 | {
13 |     /**
14 |      * @param class-string<Block> $mapping
15 |      */
16 |     public function __construct(MappingError $e, string $type, string $mapping)
17 |     {
18 |         $errorMessage = $e->getMessage() . "\n\n";
19 | 
20 |         $messages = Messages::flattenFromNode($e->node())->errors();
21 |         foreach ($messages as $message) {
22 |             $errorMessage .= (string) $message . "\n";
23 |         }
24 | 
25 |         parent::__construct(sprintf(
26 |             'The block type "%s" could not be mapped to the class "%s". The error was: %s',
27 |             $type,
28 |             $mapping,
29 |             $errorMessage,
30 |         ), 0, $e);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Exception/OptionsResolverException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | use Setono\EditorJS\BlockRenderer\BlockRendererInterface;
 8 | use Symfony\Component\OptionsResolver\Exception\ExceptionInterface;
 9 | 
10 | final class OptionsResolverException extends \InvalidArgumentException implements RendererExceptionInterface
11 | {
12 |     public function __construct(ExceptionInterface $e, BlockRendererInterface $blockRenderer)
13 |     {
14 |         parent::__construct(sprintf(
15 |             'An exception occurred when trying to resolve the options for the block renderer %s: %s',
16 |             $blockRenderer::class,
17 |             $e->getMessage(),
18 |         ), 0, $e);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Exception/ParserExceptionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | interface ParserExceptionInterface extends \Throwable
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/RendererExceptionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | interface RendererExceptionInterface extends \Throwable
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/ReservedKeyException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | final class ReservedKeyException extends \RuntimeException implements ParserExceptionInterface
 8 | {
 9 |     public function __construct(string $key, array $block)
10 |     {
11 |         $json = null;
12 | 
13 |         try {
14 |             $json = json_encode($block, \JSON_THROW_ON_ERROR);
15 |         } catch (\JsonException) {
16 |         }
17 | 
18 |         parent::__construct(sprintf(
19 |             "The key '%s' found in data is a reserved key. The inputted block JSON was:\n\n%s",
20 |             $key,
21 |             $json ?? 'Invalid',
22 |         ));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exception/UndefinedOptionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | final class UndefinedOptionException extends \RuntimeException implements RendererExceptionInterface
 8 | {
 9 |     /**
10 |      * @param list<scalar> $definedOptions
11 |      */
12 |     public function __construct(string $option, array $definedOptions)
13 |     {
14 |         parent::__construct(sprintf(
15 |             'The option "%s" is not defined. Defined options are: [%s]',
16 |             $option,
17 |             implode(', ', $definedOptions),
18 |         ));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Exception/UnmappedTypeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | use Setono\EditorJS\Parser\Parser;
 8 | 
 9 | final class UnmappedTypeException extends \RuntimeException implements ParserExceptionInterface
10 | {
11 |     public function __construct(string $type)
12 |     {
13 |         parent::__construct(sprintf(
14 |             'The block type "%s" was not mapped to any class. Did you forget to add the type to the mapping for this particular type? You can use %s',
15 |             $type,
16 |             Parser::class . '::setMapping()',
17 |         ));
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Exception/UnsupportedBlockException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Exception;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | use Setono\EditorJS\BlockRenderer\BlockRendererInterface;
 9 | 
10 | final class UnsupportedBlockException extends \RuntimeException implements RendererExceptionInterface
11 | {
12 |     public function __construct(Block $block, BlockRendererInterface $blockRenderer = null)
13 |     {
14 |         $message = sprintf(
15 |             'Could not render block "%s" (id: %s). No block renderer supports this block',
16 |             $block::class,
17 |             $block->id,
18 |         );
19 | 
20 |         if (null !== $blockRenderer) {
21 |             $message = sprintf(
22 |                 'The block renderer %s does not support the block %s (%s)',
23 |                 $blockRenderer::class,
24 |                 $block::class,
25 |                 $block->id,
26 |             );
27 |         }
28 | 
29 |         parent::__construct($message);
30 |     }
31 | 
32 |     /**
33 |      * @psalm-assert true $test
34 |      */
35 |     public static function assert(bool $test, Block $block, BlockRendererInterface $blockRenderer): void
36 |     {
37 |         if (!$test) {
38 |             throw new self($block, $blockRenderer);
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Parser/Parser.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Setono\EditorJS\Parser;
  6 | 
  7 | use CuyZ\Valinor\Mapper\MappingError;
  8 | use CuyZ\Valinor\MapperBuilder;
  9 | use Psl\Type;
 10 | use Setono\EditorJS\Block\Block;
 11 | use Setono\EditorJS\Block\DelimiterBlock;
 12 | use Setono\EditorJS\Block\EmbedBlock;
 13 | use Setono\EditorJS\Block\HeaderBlock;
 14 | use Setono\EditorJS\Block\ImageBlock;
 15 | use Setono\EditorJS\Block\ListBlock;
 16 | use Setono\EditorJS\Block\ParagraphBlock;
 17 | use Setono\EditorJS\Block\QuoteBlock;
 18 | use Setono\EditorJS\Block\RawBlock;
 19 | use Setono\EditorJS\Exception\InvalidDataException;
 20 | use Setono\EditorJS\Exception\InvalidJsonException;
 21 | use Setono\EditorJS\Exception\MappingErrorException;
 22 | use Setono\EditorJS\Exception\ReservedKeyException;
 23 | use Setono\EditorJS\Exception\UnmappedTypeException;
 24 | 
 25 | final class Parser implements ParserInterface
 26 | {
 27 |     private ?MapperBuilder $mapperBuilder = null;
 28 | 
 29 |     /** @var array<string, class-string<Block>> */
 30 |     private array $mapping = [
 31 |         'delimiter' => DelimiterBlock::class,
 32 |         'embed' => EmbedBlock::class,
 33 |         'header' => HeaderBlock::class,
 34 |         'image' => ImageBlock::class,
 35 |         'list' => ListBlock::class,
 36 |         'paragraph' => ParagraphBlock::class,
 37 |         'quote' => QuoteBlock::class,
 38 |         'raw' => RawBlock::class,
 39 |     ];
 40 | 
 41 |     public function parse(string $json): ParserResult
 42 |     {
 43 |         try {
 44 |             $data = json_decode(json: $json, associative: true, flags: \JSON_THROW_ON_ERROR);
 45 |         } catch (\JsonException $e) {
 46 |             throw new InvalidJsonException($json, $e);
 47 |         }
 48 | 
 49 |         $specification = Type\shape([
 50 |             'time' => Type\int(),
 51 |             'version' => Type\string(),
 52 |             'blocks' => Type\vec(Type\shape([
 53 |                 'id' => Type\string(),
 54 |                 'type' => Type\string(),
 55 |                 'data' => Type\mixed_dict(),
 56 |             ])),
 57 |         ]);
 58 | 
 59 |         try {
 60 |             $data = $specification->assert($data);
 61 |         } catch (Type\Exception\AssertException $e) {
 62 |             throw new InvalidDataException($json, $e);
 63 |         }
 64 | 
 65 |         /** @var list<Block> $blocks */
 66 |         $blocks = [];
 67 | 
 68 |         foreach ($data['blocks'] as $block) {
 69 |             $mapping = $this->getMapping($block['type']);
 70 | 
 71 |             foreach (array_keys($block['data']) as $key) {
 72 |                 if ('id' === $key) {
 73 |                     throw new ReservedKeyException($key, $block);
 74 |                 }
 75 |             }
 76 | 
 77 |             try {
 78 |                 $blocks[] = $this->getMapperBuilder()
 79 |                     ->mapper()
 80 |                     ->map($mapping, array_merge($block, $block['data']))
 81 |                 ;
 82 |             } catch (MappingError $e) {
 83 |                 throw new MappingErrorException($e, $block['type'], $mapping);
 84 |             }
 85 |         }
 86 | 
 87 |         return new ParserResult(
 88 |             new \DateTimeImmutable(sprintf('@%d', (int) ($data['time'] / 1000))), // the time is in milliseconds
 89 |             $data['version'],
 90 |             $blocks,
 91 |         );
 92 |     }
 93 | 
 94 |     public function getMapperBuilder(): MapperBuilder
 95 |     {
 96 |         if (null === $this->mapperBuilder) {
 97 |             $this->mapperBuilder = (new MapperBuilder())->allowSuperfluousKeys();
 98 |         }
 99 | 
100 |         return $this->mapperBuilder;
101 |     }
102 | 
103 |     /**
104 |      * @psalm-assert-if-true class-string<Block> $this->mapping[$type]
105 |      */
106 |     public function hasMapping(string $type): bool
107 |     {
108 |         return isset($this->mapping[$type]);
109 |     }
110 | 
111 |     /**
112 |      * @return class-string<Block>
113 |      *
114 |      * @throws UnmappedTypeException if the $type is not mapped
115 |      */
116 |     public function getMapping(string $type): string
117 |     {
118 |         if (!$this->hasMapping($type)) {
119 |             throw new UnmappedTypeException($type);
120 |         }
121 | 
122 |         return $this->mapping[$type];
123 |     }
124 | 
125 |     /**
126 |      * @param class-string<Block> $class
127 |      */
128 |     public function setMapping(string $type, string $class): void
129 |     {
130 |         $this->mapping[$type] = $class;
131 |     }
132 | }
133 | 


--------------------------------------------------------------------------------
/src/Parser/ParserInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Parser;
 6 | 
 7 | use Setono\EditorJS\Exception\ParserExceptionInterface;
 8 | 
 9 | interface ParserInterface
10 | {
11 |     /**
12 |      * @param string $json the output from the EditorJS javascript instance
13 |      *
14 |      * @throws ParserExceptionInterface
15 |      */
16 |     public function parse(string $json): ParserResult;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Parser/ParserResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Parser;
 6 | 
 7 | use Setono\EditorJS\Block\Block;
 8 | 
 9 | final class ParserResult
10 | {
11 |     public function __construct(
12 |         public readonly \DateTimeImmutable $time,
13 |         public readonly string $version,
14 |         /** @var list<Block> $blocks */
15 |         public readonly array $blocks,
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Renderer/Renderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Renderer;
 6 | 
 7 | use Psr\Log\LoggerAwareInterface;
 8 | use Psr\Log\LoggerInterface;
 9 | use Psr\Log\NullLogger;
10 | use Setono\EditorJS\Block\Block;
11 | use Setono\EditorJS\BlockRenderer\BlockRendererInterface;
12 | use Setono\EditorJS\Exception\UnsupportedBlockException;
13 | use Setono\EditorJS\Parser\ParserResult;
14 | 
15 | final class Renderer implements RendererInterface, LoggerAwareInterface
16 | {
17 |     private LoggerInterface $logger;
18 | 
19 |     /** @var list<BlockRendererInterface> */
20 |     private array $blockRenderers = [];
21 | 
22 |     private bool $throwOnUnsupported = true;
23 | 
24 |     public function __construct()
25 |     {
26 |         $this->logger = new NullLogger();
27 |     }
28 | 
29 |     public function render(ParserResult $parsingResult): string
30 |     {
31 |         $html = '';
32 | 
33 |         foreach ($parsingResult->blocks as $block) {
34 |             try {
35 |                 $blockRenderer = $this->getBlockRenderer($block);
36 | 
37 |                 $html .= (string) $blockRenderer->render($block);
38 |             } catch (\Throwable $e) {
39 |                 if ($this->throwOnUnsupported) {
40 |                     throw $e;
41 |                 }
42 | 
43 |                 $this->logger->error($e->getMessage());
44 |             }
45 |         }
46 | 
47 |         return $html;
48 |     }
49 | 
50 |     private function getBlockRenderer(Block $block): BlockRendererInterface
51 |     {
52 |         foreach ($this->blockRenderers as $blockRenderer) {
53 |             if ($blockRenderer->supports($block)) {
54 |                 return $blockRenderer;
55 |             }
56 |         }
57 | 
58 |         throw new UnsupportedBlockException($block);
59 |     }
60 | 
61 |     /**
62 |      * Adds a block renderer to the renderer
63 |      */
64 |     public function add(BlockRendererInterface $blockRenderer): void
65 |     {
66 |         $this->blockRenderers[] = $blockRenderer;
67 |     }
68 | 
69 |     /**
70 |      * If true the renderer will throw any exceptions it encounters.
71 |      * If false it will not throw the exceptions, but only log them as errors
72 |      */
73 |     public function throwOnUnsupported(bool $throwOnUnsupported): void
74 |     {
75 |         $this->throwOnUnsupported = $throwOnUnsupported;
76 |     }
77 | 
78 |     public function setLogger(LoggerInterface $logger): void
79 |     {
80 |         $this->logger = $logger;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Renderer/RendererInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Setono\EditorJS\Renderer;
 6 | 
 7 | use Setono\EditorJS\Exception\RendererExceptionInterface;
 8 | use Setono\EditorJS\Parser\ParserResult;
 9 | 
10 | interface RendererInterface
11 | {
12 |     /**
13 |      * Takes a parser result as input and returns HTML as a string
14 |      *
15 |      * @throws RendererExceptionInterface
16 |      */
17 |     public function render(ParserResult $parsingResult): string;
18 | }
19 | 


--------------------------------------------------------------------------------