The advice of session locale resolver is required but the session has not been started and headers had been already sent. Either start your sessions earlier or disable the SessionResolver. search► skip error►

34:        {
35:            $this->sessionSection[self::$parameter] = $locale;
36:            return $this;
37:        }
38:    
39:        public function resolve(
40:            Translator $translator
41:        ): ?string
42:        {
43:            if (!$this->session->isStarted() && $this->httpResponse->isSent()) {
44:                trigger_error('The advice of session locale resolver is required but the session has not been started and headers had been already sent. Either start your sessions earlier or disable the SessionResolver.', E_USER_WARNING);
45:                return null;
46:            }
47:    
48:            $locale = $this->sessionSection[self::$parameter] ?? null;

512

47:        ): string
48:        {
49:            foreach ($this->resolvers as $v1) {
50:                $resolver = $this->container
51:                    ->getByType($v1);
52:    
53:                if (!$resolver instanceof ResolverInterface) {
54:                    throw new InvalidState('Resolver "' . $v1 . '" must implement interface "' . ResolverInterface::class . '".');
55:                }
56:    
57:                $locale = $resolver->resolve($translator);
58:    
59:                if (
60:                    $locale !== null &&
61:                    (

241:        ): void
242:        {
243:            parent::addResource($format, $resource, $locale, $domain);
244:    
245:            $this->resourcesLocales[$locale] = true;
246:        }
247:    
248:        public function getLocale(): string
249:        {
250:            if (parent::getLocale() === $this->initLang) {
251:                $this->setLocale($this->localeResolver->resolve($this));
252:            }
253:    
254:            return parent::getLocale();
255:        }

219:            ) {
220:                return $this->formatter->formatIntl($catalogue->get($id, $domain), $locale, $parameters);
221:            }
222:    
223:            return $this->formatter->format($catalogue->get($id, $domain), $locale, $parameters);
224:        }
225:    
226:        public function getCatalogue(?string $locale = null): MessageCatalogueInterface
227:        {
228:            if (!$locale) {
229:                $locale = $this->getLocale();
230:            } else {
231:                $this->assertValidLocale($locale);
232:            }
233:    

410:                                [
411:                                    'id' => $id,
412:                                    'domain' => $domain,
413:                                    'locale' => $locale ?? $this->getLocale(),
414:                                ]
415:                            );
416:                    }
417:                }
418:    
419:                if ($this->tracyPanel !== null) {
420:                    if (!$this->getCatalogue($locale)->has($id, $domain)) {
421:                        $this->tracyPanel
422:                            ->addMissingTranslation($id, $domain);
423:                    }
424:                }

null

369:            }
370:    
371:            $generator = $this->getTranslateKeyGenerator();
372:    
373:            $params = iterator_to_array($generator($params));
374:    
375:            if (Validators::isNumeric($count)) {
376:                $params += ['%count%' => $count];
377:            }
378:    
379:            $translated = $this->trans($message, $params, $domain, $locale);
380:    
381:            if ($this->returnOriginalMessage) {
382:                if (!$this->getCatalogue($locale)->has($message, $domain)) {
383:                    return $originalMessage;

'homepage.title'

array (0)

'websolution'

null

45:        public function getFilters(): array
46:        {
47:            return [
48:                'translate' => function (FilterInfo $fi, mixed ...$args): string {
49:                    $message = array_shift($args);
50:    
51:                    if (!is_string($message) && !$message instanceof \Stringable) {
52:                        return '';
53:                    }
54:    
55:                    return (string) $this->translator->translate($message, ...$args);
56:                },
57:            ];
58:        }
59:    

'homepage.title'

128:    
129:    
130:        private function callInfoAwareAsClassic(callable $filter, mixed ...$args): mixed
131:        {
132:            array_unshift($args, $info = new FilterInfo);
133:            if ($args[1] instanceof HtmlStringable) {
134:                $args[1] = $args[1]->__toString();
135:                $info->contentType = ContentType::Html;
136:            }
137:    
138:            $res = $filter(...$args);
139:            return $info->contentType === ContentType::Html
140:                ? new Html($res)
141:                : $res;
142:        }

'websolution.homepage.title'

53:        }
54:    
55:    
56:        /**
57:         * Returns the named filter as a simple callable (without FilterInfo context argument).
58:         */
59:        public function __get(string $name): callable
60:        {
61:            [$callback, $infoAware] = $this->prepareFilter($name);
62:            return $this->$name = $infoAware
63:                ? fn(...$args) => $this->callInfoAwareAsClassic($callback, ...$args)
64:                : $callback;
65:        }
66:    
67:    

'websolution.homepage.title'

127:                    : '.';
128:                $name = $layer ? "$layer $name" : $name;
129:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
130:            }
131:    
132:            $fn = reset($block->functions);
133:            assert($fn !== false);
134:            $this->renderingBlocks[] = $name;
135:            try {
136:                $this->filter(
137:                    fn() => $fn($params),
138:                    $mod,
139:                    $block->contentType ?? static::ContentType,
140:                    "block $name",
141:                );

null

235:    
236:    
237:        /**
238:         * Captures output to string.
239:         * @internal
240:         */
241:        public function capture(callable $function): string
242:        {
243:            try {
244:                ob_start(fn() => '');
245:                $function();
246:                return ob_get_clean();
247:            } catch (\Throwable $e) {
248:                ob_end_clean();
249:                throw $e;

212:    
213:        /**
214:         * @param  string|\Closure|null  $targetType  content-type name or modifier closure
215:         */
216:        private function filter(callable $producer, string|\Closure|null $targetType, string $contentType, string $name): void
217:        {
218:            if ($targetType === null || $targetType === $contentType) {
219:                $producer();
220:    
221:            } elseif ($targetType instanceof \Closure) {
222:                echo $targetType($this->capture($producer), $contentType);
223:    
224:            } elseif ($filter = Escaper::getConvertor($contentType, $targetType)) {
225:                echo $filter($this->capture($producer));
226:    

126:                    ? ", did you mean '$t'?"
127:                    : '.';
128:                $name = $layer ? "$layer $name" : $name;
129:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
130:            }
131:    
132:            $fn = reset($block->functions);
133:            assert($fn !== false);
134:            $this->renderingBlocks[] = $name;
135:            try {
136:                $this->filter(
137:                    fn() => $fn($params),
138:                    $mod,
139:                    $block->contentType ?? static::ContentType,
140:                    "block $name",

'html'

'block title'

 86:                    }
 87:    
 88:                } elseif ($this->parentName) { // extends
 89:                    $this->params = $params;
 90:                    $this->createTemplate($this->parentName, $this->parentArgs + $params, 'extends')->render($block);
 91:    
 92:                } elseif ($block !== null) { // single block rendering
 93:                    $this->renderBlock($block, $this->params);
 94:    
 95:                } else {
 96:                    $this->main($params);
 97:                }
 98:            } finally {
 99:                foreach ($extensions as $extension) {
100:                    $extension->afterRender($this);

null

80:                    $this->parentName = ($this->global->coreParentFinder)($this);
81:                }
82:    
83:                if ($this->referenceType === 'import') {
84:                    if ($this->parentName) {
85:                        throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
86:                    }
87:    
88:                } elseif ($this->parentName) { // extends
89:                    $this->params = $params;
90:                    $this->createTemplate($this->parentName, $this->parentArgs + $params, 'extends')->render($block);
91:    
92:                } elseif ($block !== null) { // single block rendering
93:                    $this->renderBlock($block, $this->params);
94:    

null

76:    
77:    
78:        /**
79:         * Renders template to output.
80:         * @param  object|mixed[]  $params
81:         */
82:        public function render(string $name, object|array $params = [], ?string $block = null): void
83:        {
84:            $template = $this->createTemplate($name, Helpers::resolveParams($this, $params));
85:            $template->global->coreCaptured = false;
86:            $template->render($block);
87:        }
88:    
89:    
90:        /**

null

32:    
33:    
34:        /**
35:         * Renders template to output.
36:         * @param  array<string, mixed>  $params
37:         */
38:        public function render(?string $file = null, array $params = []): void
39:        {
40:            Nette\Utils\Arrays::toObject($params, $this);
41:            $file ??= $this->file ?? throw new Nette\InvalidStateException('Template file name was not set.');
42:            $this->latte->render($file, $this);
43:        }
44:    
45:    
46:        /**

'/var/www/html/app/Presentation/Home/default.latte'

26:            return $this->source;
27:        }
28:    
29:    
30:        /**
31:         * Sends response to output.
32:         */
33:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
34:        {
35:            if ($this->source instanceof Nette\Application\UI\Template) {
36:                $this->source->render();
37:    
38:            } else {
39:                echo $this->source;
40:            }

58:    
59:    
60:        /**
61:         * Dispatches an HTTP request to a front controller.
62:         */
63:        public function run(): void
64:        {
65:            try {
66:                Arrays::invoke($this->onStartup, $this);
67:                $this->processRequest($this->createInitialRequest())
68:                    ->send($this->httpRequest, $this->httpResponse);
69:                Arrays::invoke($this->onShutdown, $this);
70:    
71:            } catch (\Throwable $e) {
72:                $this->sendHttpCode($e);

1:    <?php declare(strict_types=1);
2:    
3:    require __DIR__ . '/../vendor/autoload.php';
4:    
5:    $bootstrap = new App\Bootstrap;
6:    $container = $bootstrap->bootWebApplication();
7:    $application = $container->getByType(Nette\Application\Application::class);
8:    $application->run();