lean/meta/definitions/routes.php

<?php

use function DI\autowire, DI\create, DI\get;

use League\Route\Strategy\ApplicationStrategy,
    League\Route\Http\Exception\NotFoundException,
    League\Route\Router;

use Psr\Http\Message\ResponseFactoryInterface,
    Psr\Container\ContainerInterface,
    Psr\Http\Message\ResponseInterface,
    Psr\Http\Message\ServerRequestInterface,
    Psr\Http\Server\MiddlewareInterface,
    Psr\Http\Server\RequestHandlerInterface,
    Psr\SimpleCache\CacheInterface;

use TheBugs\JavascriptMiddleware;

use Cronard\CronardMiddleware;

use Tuupola\Middleware\HttpBasicAuthentication;

use Notes\Route\RouteFetcher;

use Notes\Breadcrumb\Breadcrumb;

use Ulmus\User\Lib\Authenticate;

use Storage\SessionMiddleware;

return [
    Lean\Routing::class => autowire(Lean\Routing::class),

    RouteFetcher::class => function($c) {
        $fetcher = new RouteFetcher(null, [], null, $c->get('routes.caching'));

        $fetcher->setFolderList(array_map(function($item) {
            return $item;
        }, $c->get(Lean\Lean::class)->getRoutable()));

        return $fetcher;
    },

    Breadcrumb::class => function($c) {
        $breadcrumb = new Breadcrumb(null, [], null, $c->get('breadcrumbs.caching'));

        $breadcrumb->setFolderList(array_map(function($item) {
            return $item;
        }, $c->get(Lean\Lean::class)->getRoutable()));

        return $breadcrumb;
    },

    ApplicationStrategy::class => function($c) {
        return new class($c->get(Picea\Picea::class)) extends ApplicationStrategy {

            public Picea\Picea $picea;

            public function __construct(Picea\Picea $picea) {
                $this->picea = $picea;
            }

            public function getNotFoundDecorator(NotFoundException $exception): MiddlewareInterface
            {
                return new class($this->picea) implements MiddlewareInterface {

                    protected Picea\Picea $picea;

                    public function __construct(Picea\Picea $picea) {
                        $this->picea = $picea;
                    }

                    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
                    {
                        return new Laminas\Diactoros\Response\HtmlResponse($this->picea->renderHtml("lean/error/404", [], $this), 404);
                    }

                };
            }

        };
    },

    'routes.middlewares'  => [ "dump", "errorHandler", SessionMiddleware::class, CronardMiddleware::class, Mcnd\Event\EventMiddleware::class, HttpBasicAuthentication::class ],

    'routes.list' => function($c) {
        return function (ContainerInterface $container) {
            $router = $container->get(Router::class);
            foreach($container->get('routes.middlewares') as $i => $middleware) {
                if ( $container->has($middleware) ) {
                    $router->middleware($container->get($middleware));
                }
            }

            $routing = $container->get(Lean\Routing::class);

            $routing->registerRoute($container, getenv('URL_BASE'));

            return $router;
        };
    },
];