6470:        {
6471:            return new class ($this) implements App\FrontendModule\Components\Map\MapFactory {
6472:                public function __construct(
6473:                    private Container_734d7743ad $container,
6474:                ) {
6475:                }
6476:    
6477:    
6478:                public function create(string $placeholder): App\FrontendModule\Components\Map\Map
6479:                {
6480:                    $service = new App\FrontendModule\Components\Map\Map(
6481:                        $placeholder,
6482:                        $this->container->getService('model.orm'),
6483:                        $this->container->getService('imageStorage.imageStorage'),
6484:                    );

'homepage'

 9:    
10:        private MapFactory $mapFactory;
11:    
12:        public function injectMap(MapFactory $mapFactory): void
13:        {
14:            $this->mapFactory = $mapFactory;
15:        }
16:    
17:        protected function createComponentMap(): Multiplier
18:        {
19:            return new Multiplier(fn (string $placeholder): Map => $this->mapFactory->create($placeholder));
20:        }
21:    
22:    }

'homepage'

22:    
23:    
24:        public function __construct(callable $factory)
25:        {
26:            $this->factory = $factory;
27:        }
28:    
29:    
30:        protected function createComponent(string $name): ?Nette\ComponentModel\IComponent
31:        {
32:            return ($this->factory)($name, $this);
33:        }
34:    }

'homepage'

116:    
117:            if (!isset($this->components[$name])) {
118:                if (!preg_match(self::NameRegexp, $name)) {
119:                    if ($throw) {
120:                        throw new Nette\InvalidArgumentException("Component name must be non-empty alphanumeric string, '$name' given.");
121:                    }
122:    
123:                    return null;
124:                }
125:    
126:                $component = $this->createComponent($name);
127:                if ($component && !isset($this->components[$name])) {
128:                    $this->addComponent($component, $name);
129:                }
130:            }

'homepage'

128:                    $this->addComponent($component, $name);
129:                }
130:            }
131:    
132:            $component = $this->components[$name] ?? null;
133:            if ($component !== null) {
134:                if (!isset($parts[1])) {
135:                    return $component;
136:    
137:                } elseif ($component instanceof IContainer) {
138:                    return $component->getComponent($parts[1], $throw);
139:    
140:                } elseif ($throw) {
141:                    throw new Nette\InvalidArgumentException("Component with name '$name' is not container and cannot have '$parts[1]' component.");
142:                }

'homepage'

true

241:    
242:            if (!$block) {
243:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
244:                    ? ", did you mean '$t'?"
245:                    : '.';
246:                $name = $layer ? "$layer $name" : $name;
247:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
248:            }
249:    
250:            $this->filter(
251:                fn() => reset($block->functions)($params),
252:                $mod,
253:                $block->contentType,
254:                "block $name",
255:            );

null

300:            $block->functions = array_merge($block->functions, $functions);
301:        }
302:    
303:    
304:        /**
305:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
306:         */
307:        private function filter(callable $function, string|\Closure|null $mod, string $contentType, string $name): void
308:        {
309:            if ($mod === null || $mod === $contentType) {
310:                $function();
311:    
312:            } elseif ($mod instanceof \Closure) {
313:                echo $mod($this->capture($function), $contentType);
314:    

240:                : ($this->blocks[self::LayerLocal][$name] ?? $this->blocks[self::LayerTop][$name] ?? null);
241:    
242:            if (!$block) {
243:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
244:                    ? ", did you mean '$t'?"
245:                    : '.';
246:                $name = $layer ? "$layer $name" : $name;
247:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
248:            }
249:    
250:            $this->filter(
251:                fn() => reset($block->functions)($params),
252:                $mod,
253:                $block->contentType,
254:                "block $name",

'html'

'html'

'block content'

241:    
242:            if (!$block) {
243:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
244:                    ? ", did you mean '$t'?"
245:                    : '.';
246:                $name = $layer ? "$layer $name" : $name;
247:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
248:            }
249:    
250:            $this->filter(
251:                fn() => reset($block->functions)($params),
252:                $mod,
253:                $block->contentType,
254:                "block $name",
255:            );

null

300:            $block->functions = array_merge($block->functions, $functions);
301:        }
302:    
303:    
304:        /**
305:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
306:         */
307:        private function filter(callable $function, string|\Closure|null $mod, string $contentType, string $name): void
308:        {
309:            if ($mod === null || $mod === $contentType) {
310:                $function();
311:    
312:            } elseif ($mod instanceof \Closure) {
313:                echo $mod($this->capture($function), $contentType);
314:    

240:                : ($this->blocks[self::LayerLocal][$name] ?? $this->blocks[self::LayerTop][$name] ?? null);
241:    
242:            if (!$block) {
243:                $hint = $layer && ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
244:                    ? ", did you mean '$t'?"
245:                    : '.';
246:                $name = $layer ? "$layer $name" : $name;
247:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
248:            }
249:    
250:            $this->filter(
251:                fn() => reset($block->functions)($params),
252:                $mod,
253:                $block->contentType,
254:                "block $name",

null

'html'

'block bodyStructure'

148:                }
149:    
150:            } elseif ($this->parentName) { // extends
151:                $this->params = $params;
152:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
153:    
154:            } elseif ($block !== null) { // single block rendering
155:                $this->renderBlock($block, $this->params);
156:    
157:            } else {
158:                $this->main($params);
159:            }
160:        }
161:    
162:    

null

142:                $this->parentName = ($this->global->coreParentFinder)($this);
143:            }
144:    
145:            if ($this->referenceType === 'import') {
146:                if ($this->parentName) {
147:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
148:                }
149:    
150:            } elseif ($this->parentName) { // extends
151:                $this->params = $params;
152:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
153:    
154:            } elseif ($block !== null) { // single block rendering
155:                $this->renderBlock($block, $this->params);
156:    

null

142:                $this->parentName = ($this->global->coreParentFinder)($this);
143:            }
144:    
145:            if ($this->referenceType === 'import') {
146:                if ($this->parentName) {
147:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
148:                }
149:    
150:            } elseif ($this->parentName) { // extends
151:                $this->params = $params;
152:                $this->createTemplate($this->parentName, $params, 'extends')->render($block);
153:    
154:            } elseif ($block !== null) { // single block rendering
155:                $this->renderBlock($block, $this->params);
156:    

null

63:    
64:    
65:        /**
66:         * Renders template to output.
67:         * @param  object|mixed[]  $params
68:         */
69:        public function render(string $name, object|array $params = [], ?string $block = null): void
70:        {
71:            $template = $this->createTemplate($name, $this->processParams($params));
72:            $template->global->coreCaptured = false;
73:            $template->render($block);
74:        }
75:    
76:    
77:        /**

null

36:    
37:        /**
38:         * Renders template to output.
39:         */
40:        public function render(?string $file = null, array $params = []): void
41:        {
42:            Nette\Utils\Arrays::toObject($params, $this);
43:            if (isset($this->blueprint)) {
44:                Nodes\TemplatePrintNode::printClass($this->getParameters(), $this->blueprint);
45:            }
46:            $this->latte->render($file ?: $this->file, $this);
47:        }
48:    
49:    
50:        /**

'/var/www/rezidence-jablonskeho.cz/data/www/rezidence-jablonskeho.cz/App/FrontendModule/templates/Contact/default.latte'

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

148:    
149:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
150:            $response = $this->presenter->run(clone $request);
151:    
152:            if ($response instanceof Responses\ForwardResponse) {
153:                $request = $response->getRequest();
154:                goto process;
155:            }
156:    
157:            Arrays::invoke($this->onResponse, $this, $response);
158:            $response->send($this->httpRequest, $this->httpResponse);
159:        }
160:    
161:    
162:        public function createErrorRequest(\Throwable $e): ?Request

66:        }
67:    
68:    
69:        /**
70:         * Dispatch a HTTP request to a front controller.
71:         */
72:        public function run(): void
73:        {
74:            try {
75:                Arrays::invoke($this->onStartup, $this);
76:                $this->processRequest($this->createInitialRequest());
77:                Arrays::invoke($this->onShutdown, $this);
78:    
79:            } catch (\Throwable $e) {
80:                $this->sendHttpCode($e);

 9:    $parameters    = $container->getParameters();
10:    
11:    if ($timeLimit = $parameters['time_limit'] ?? null) {
12:        @set_time_limit($timeLimit);
13:    }
14:    
15:    if ($memoryLimit = $parameters['memory_limit'] ?? null) {
16:        @ini_set('memory_limit', $memoryLimit . 'M');
17:    }
18:    
19:    $container->getByType(Application::class)->run();
20:    exit;