AbstractComponentRenderer.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\UI\Implementation\Render;

use ILIAS\Data\Factory as DataFactory;
use ILIAS\UI\Component\Component;
use ILIAS\UI\Component\JavaScriptBindable;
use ILIAS\UI\Component\Triggerer;
use ILIAS\UI\Implementation\FactoryInternal;
use ILIAS\UI\HelpTextRetriever;
use ILIAS\UI\Help;
use ILIAS\Language\Language;
use InvalidArgumentException;
use LogicException;
use ILIAS\UI\Implementation\Component\Input\UploadLimitResolver;
use ILIAS\UI\Renderer;

abstract class AbstractComponentRenderer implements ComponentRenderer, HelpTextRetriever
{
    private static array $component_storage;

    final public function __construct(
        private FactoryInternal $ui_factory,
        private TemplateFactory $tpl_factory,
        private Language $lng,
        private JavaScriptBinding $js_binding,
        private ImagePathResolver $image_path_resolver,
        private DataFactory $data_factory,
        private HelpTextRetriever $help_text_retriever,
        private UploadLimitResolver $upload_limit_resolver,
    ) {
    }

    public function registerResources(ResourceRegistry $registry): void
    {
        $registry->register('assets/js/core.js');
    }

    final protected function getUIFactory(): FactoryInternal
    {
        return $this->ui_factory;
    }

    final protected function getDataFactory(): DataFactory
    {
        return $this->data_factory;
    }

    final protected function getUploadLimitResolver(): UploadLimitResolver
    {
        return $this->upload_limit_resolver;
    }

    final public function txt(string $id): string
    {
        return $this->lng->txt($id);
    }

    final public function toJS($key): void
    {
        $this->lng->toJS($key);
    }

    public function getLangKey(): string
    {
        return $this->lng->getLangKey();
    }

    final protected function getJavascriptBinding(): JavaScriptBinding
    {
        return $this->js_binding;
    }

    final protected function getTemplate(string $name, bool $purge_unfilled_vars, bool $purge_unused_blocks): Template
    {
        $path = $this->getTemplatePath($name);
        return $this->getTemplateRaw($path, $purge_unfilled_vars, $purge_unused_blocks);
    }

    protected function getTemplatePath(string $name): string
    {
        $component = $this->getMyComponent();
        return "components/ILIAS/UI/src/templates/default/$component/$name";
    }

    private function getTemplateRaw(string $path, bool $purge_unfilled_vars, bool $purge_unused_blocks): Template
    {
        return $this->tpl_factory->getTemplate($path, $purge_unfilled_vars, $purge_unused_blocks);
    }

    final protected function bindJavaScript(JavaScriptBindable $component): ?string
    {
        if ($component instanceof Triggerer) {
            $component = $this->addTriggererOnLoadCode($component);
        }
        return $this->bindOnloadCode($component);
    }

    final protected function createId(): string
    {
        return $this->js_binding->createId();
    }

    private function bindOnloadCode(JavaScriptBindable $component): ?string
    {
        $binder = $component->getOnLoadCode();
        if ($binder === null) {
            return null;
        }

        $id = $this->js_binding->createId();
        $on_load_code = $binder($id);
        if (!is_string($on_load_code)) {
            throw new LogicException(
                "Expected JavaScript binder to return string" .
                " (used component: " . get_class($component) . ")"
            );
        }
        $this->js_binding->addOnLoadCode($on_load_code);
        return $id;
    }

    private function addTriggererOnLoadCode(Triggerer $triggerer): JavaScriptBindable
    {
        $triggered_signals = $triggerer->getTriggeredSignals();
        if (count($triggered_signals) == 0) {
            return $triggerer;
        }
        return $triggerer->withAdditionalOnLoadCode(function ($id) use ($triggered_signals): string {
            $code = "";
            foreach ($triggered_signals as $triggered_signal) {
                $signal = $triggered_signal->getSignal();
                $event = $triggered_signal->getEvent();
                $options = json_encode($signal->getOptions());
                //Note this switch is necessary since $(#...).on('load', ...) could be fired before the binding of the event.
                //Same seems true fro ready, see: #27456
                if ($event == 'load' || $event == 'ready') {
                    $code .=
                            "$(document).trigger('$signal',
                                                        {
                                                                'id' : '$signal', 'event' : '$event',
                                                                'triggerer' : $('#$id'),
                                                                'options' : JSON.parse('$options')
                                                        }
                                                );";
                } else {
                    $code .=
                    "$('#$id').on('$event', function(event) {
                                                $(this).trigger('$signal',
                                                        {
                                                                'id' : '$signal', 'event' : '$event',
                                                                'triggerer' : $(this),
                                                                'options' : JSON.parse('$options')
                                                        }
                                                );
                                                return false;
                                        });";
                }
            }
            return $code;
        });
    }

    final protected function cannotHandleComponent(Component $component): never
    {
        throw new LogicException(
            sprintf(
                "%s could not render component %s",
                static::class,
                get_class($component)
            )
        );
    }

    private function getMyComponent()
    {
        $class = get_class($this);
        if (isset(self::$component_storage[$class])) {
            return self::$component_storage[$class];
        }
        $matches = array();
        // Extract component
        $re = "%ILIAS\\\\UI\\\\Implementation\\\\Component\\\\(\\w+)\\\\(\\w+)%";
        preg_match($re, $class, $matches);
        if (preg_match($re, $class, $matches) !== 1) {
            throw new LogicException("The Renderer needs to be located in ILIAS\\UI\\Implementation\\Component\\*.");
        }
        self::$component_storage[$class] = $matches[1];

        return self::$component_storage[$class];
    }

    public function getImagePathResolver(): ImagePathResolver
    {
        return $this->image_path_resolver;
    }

    public function getHelpText(Help\Purpose $purpose, Help\Topic ...$topics): array
    {
        return $this->help_text_retriever->getHelpText($purpose, ...$topics);
    }

    /*
     * This is supposed to unify rendering of tooltips over all components.
     */
    protected ?TooltipRenderer $tooltip_renderer = null;

    protected function getTooltipRenderer(): TooltipRenderer
    {
        if ($this->tooltip_renderer === null) {
            $this->tooltip_renderer = new TooltipRenderer(
                $this,
                fn($path, $f1, $f2) => $this->getTemplateRaw($path, $f1, $f2)
            );
        }
        return $this->tooltip_renderer;
    }

    protected function convertSpecialCharacters(string $value): string
    {
        return htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, 'utf-8');
    }

    public function getComponentCanonicalNameAttribute(Component $component): string
    {
        return str_replace(' ', '-', strtolower($component->getCanonicalName()));
    }
}