lagdo / ui-builder

src/Builder/Engine/Scope.php

<?php

namespace Lagdo\UiBuilder\Builder\Engine;

use Lagdo\UiBuilder\Component\HtmlComponent;
use Lagdo\UiBuilder\Component\HtmlElement;
use Lagdo\UiBuilder\Component\Html\Element;
use Lagdo\UiBuilder\Component\Virtual\VirtualComponent;

use function is_a;
use function implode;

class Scope
{
    /**
     * @var array<Element>
     */
    protected $elements = [];

    /**
     * @var array<Element|HtmlComponent>
     */
    protected $children = [];

    /**
     * The constructor
     *
     * @param HtmlComponent $parent
     */
    public function __construct(protected HtmlComponent $parent)
    {}

    /**
     * Create the corresponding components
     *
     * @param mixed $component
     *
     * @return void
     */
    private function expand(mixed $component): void
    {
        if (is_a($component, Element::class) ||
            is_a($component, HtmlComponent::class)) {
            $this->children[] = $component;
            return;
        }

        if (is_a($component, VirtualComponent::class)) {
            // Recursively expand the children of the virtual components.
            foreach ($component->children() as $childElement) {
                $this->expand($childElement);
            }
        }
    }

    /**
     * @param HtmlComponent $component
     * @param array<Element> $children
     *
     * @return HtmlElement
     */
    private function getElement(HtmlComponent $component, array $children): HtmlElement
    {
        $element = $component->element();
        $element->addChildren($children);
        // Nest the component element into its wrappers elements.
        foreach ($component->wrappers() as $wrapper) {
            $wrapper->addChild($element);
            $element = $wrapper;
        }

        return $element;
    }

    /**
     * @param Engine $engine
     * @param array $arguments The arguments passed to the component
     *
     * @return void
     */
    public function build(Engine $engine, array $arguments): void
    {
        foreach ($arguments as $argument) {
            $this->expand($argument);
        }

        foreach ($this->children as $component) {
            if (is_a($component, Element::class)) {
                // A children of type Element doesn't need any further processing.
                $this->elements[] = $component;
                continue;
            }

            // The component is an instance of HtmlComponent.
            $isForm = $component->element()->tag() === 'form';
            if ($isForm) {
                $engine->formStarted();
            }

            // Allow the component libraries to react to the parent-child relation.
            $component->expanded($this->parent);

            $scope = new Scope($component);
            // Recursively build the component children.
            $scope->build($engine, $component->children());

            if ($isForm) {
                $engine->formEnded();
            }

            // Add the child component element and its siblings to the scope elements.
            $this->elements = [

array($this->elements, $component->siblings('prev'), $this->getElement($component, $scope->elements), $component->siblings('next')) is of type array<integer,Lagdo\UiBuilder\Component\HtmlElement|Lagdo\UiBuilder\Component\Html\Element[]|array>, but the property $elements was declared to be of type Lagdo\UiBuilder\Component\Html\Element[]. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

                ...$this->elements,
                ...$component->siblings('prev'),
                $this->getElement($component, $scope->elements),
                ...$component->siblings('next'),
            ];
        }
    }

    /**
     * @return string
     */
    public function html(): string
    {
        // Merge all the generated elements.
        return implode('', $this->elements);
    }
}