@vituum/vite-plugin-latte 0.1.8

package/vendor/latte/latte/src/Latte/Essential/Passes.php

@@ -0,0 +1,115 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Essential;
+
+use Latte;
+use Latte\CompileException;
+use Latte\Compiler\ExpressionBuilder;
+use Latte\Compiler\Node;
+use Latte\Compiler\Nodes\AuxiliaryNode;
+use Latte\Compiler\Nodes\Php\Expression\FunctionCallNode;
+use Latte\Compiler\Nodes\Php\Expression\VariableNode;
+use Latte\Compiler\Nodes\Php\NameNode;
+use Latte\Compiler\Nodes\TemplateNode;
+use Latte\Compiler\NodeTraverser;
+use Latte\Compiler\PrintContext;
+use Latte\Essential\Nodes\ForeachNode;
+
+
+final class Passes
+{
+	use Latte\Strict;
+
+	/**
+	 * Checks if foreach overrides template variables.
+	 */
+	public static function overwrittenVariablesPass(TemplateNode $node): void
+	{
+		$vars = [];
+		(new NodeTraverser)->traverse($node, function (Node $node) use (&$vars) {
+			if ($node instanceof ForeachNode && $node->checkArgs) {
+				foreach ([$node->key, $node->value] as $var) {
+					if ($var instanceof VariableNode) {
+						$vars[$var->name][] = $node->position->line;
+					}
+				}
+			}
+		});
+		if ($vars) {
+			array_unshift($node->head->children, new AuxiliaryNode(fn(PrintContext $context) => $context->format(
+				<<<'XX'
+					if (!$this->getReferringTemplate() || $this->getReferenceType() === 'extends') {
+						foreach (array_intersect_key(%dump, $this->params) as $ʟ_v => $ʟ_l) {
+							trigger_error("Variable \$$ʟ_v overwritten in foreach on line $ʟ_l");
+						}
+					}
+
+					XX,
+				array_map(fn($l) => implode(', ', $l), $vars),
+			)));
+		}
+	}
+
+
+	/**
+	 * Move TemplatePrintNode to head.
+	 */
+	public static function moveTemplatePrintToHeadPass(TemplateNode $templateNode): void
+	{
+		(new NodeTraverser)->traverse($templateNode->main, function (Node $node) use ($templateNode) {
+			if ($node instanceof Latte\Essential\Nodes\TemplatePrintNode) {
+				array_unshift($templateNode->head->children, $node);
+				return new Latte\Compiler\Nodes\NopNode;
+			}
+		});
+	}
+
+
+	/**
+	 * Enable custom functions.
+	 */
+	public static function customFunctionsPass(TemplateNode $node, array $functions): void
+	{
+		$names = array_keys($functions);
+		$names = array_combine(array_map('strtolower', $names), $names);
+
+		(new NodeTraverser)->traverse($node, function (Node $node) use ($names) {
+			if (($node instanceof FunctionCallNode || $node instanceof FunctionCallableNode)
+				&& $node->name instanceof NameNode
+				&& ($orig = $names[strtolower((string) $node->name)] ?? null)
+			) {
+				if ((string) $node->name !== $orig) {
+					trigger_error("Case mismatch on function name '{$node->name}', correct name is '$orig'.", E_USER_WARNING);
+				}
+
+				return ExpressionBuilder::function(
+					ExpressionBuilder::variable('$this')->property('global')->property('fn')->property($orig),
+					$node->args,
+				)->build();
+			}
+		});
+	}
+
+
+	/**
+	 * $ʟ_xxx variables are forbidden
+	 */
+	public static function internalVariablesPass(TemplateNode $node): void
+	{
+		(new NodeTraverser)->traverse($node, function (Node $node) {
+			if ($node instanceof VariableNode
+				&& is_string($node->name)
+				&& (str_starts_with($node->name, 'ʟ_'))
+			) {
+				throw new CompileException("Forbidden variable \$$node->name.", $node->position);
+			}
+		});
+	}
+}

package/vendor/latte/latte/src/Latte/Essential/RawPhpExtension.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Essential;
+
+use Latte;
+
+
+/**
+ * Raw PHP in {php ...}
+ */
+final class RawPhpExtension extends Latte\Extension
+{
+	use Latte\Strict;
+
+	public function getTags(): array
+	{
+		return [
+			'php' => [Nodes\RawPhpNode::class, 'create'],
+		];
+	}
+}

package/vendor/latte/latte/src/Latte/Essential/RollbackException.php

@@ -0,0 +1,16 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Essential;
+
+
+/** @internal */
+class RollbackException extends \Exception
+{
+}

package/vendor/latte/latte/src/Latte/Essential/Tracer.php

@@ -0,0 +1,117 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Essential;
+
+use Latte;
+use Latte\Engine;
+use Latte\Runtime\Template;
+
+
+/**
+ * @internal
+ */
+final class Tracer
+{
+	public static function throw(): void
+	{
+		$e = new Latte\RuntimeException('Your location in Latte templates');
+		$trace = debug_backtrace();
+		$props = [
+			'file' => $trace[1]['object']->getName(),
+			'line' => self::getSourceLine($trace[0]['file'], $trace[0]['line']),
+			'trace' => self::generateTrace($trace),
+		];
+		foreach ($props as $name => $value) {
+			$ref = new \ReflectionProperty('Exception', $name);
+			$ref->setAccessible(true);
+			$ref->setValue($e, $value);
+		}
+
+		throw $e;
+	}
+
+
+	private static function generateTrace(array $trace): array
+	{
+		$res = [];
+		foreach ($trace as $i => $item) {
+			$object = $item['object'] ?? null;
+			if ($object instanceof Template) {
+				$method = $item['function'] ?? '';
+
+				if (str_starts_with($method, 'block')) {
+					// begin of block
+					$comment = (new \ReflectionMethod($object, $method))->getDocComment();
+					$res[] = [
+						'function' => preg_match('~(\{.+\})~', $comment, $m) ? $m[1] : '?',
+						'file' => $object->getName(),
+						'line' => preg_match('~ on line (\d+)~', $comment, $m) ? (int) $m[1] : 0,
+						'args' => [], // $L_args is not true, will be added in next step
+					];
+
+				} elseif ($method === 'render' && $object->getReferenceType()) {
+					// begin of included/extended/... file
+					$res[] = [
+						'function' => '{' . $object->getReferenceType() . ' ' . basename($object->getName()) . '}',
+						'file' => $object->getReferringTemplate()->getName(),
+						'line' => 0, // will be added in next step
+						'args' => self::filterParams($object->getParameters()),
+					];
+
+				} elseif ($method === 'renderToContentType') {
+					// {include file}, extends, embed, sandbox, ...
+					$res[count($res) - 1]['line'] = self::getSourceLine($item['file'], $item['line']);
+
+				} elseif ($method === 'renderBlock' || $method === 'renderBlockParent') {
+					// {include block}
+					$res[count($res) - 1]['args'] = self::filterParams($item['args'][1] + $object->getParameters());
+
+					if ($method !== 'renderBlock' || isset($item['args'][2])) { // is not {block}
+						$res[] = [
+							'function' => '{include ' . ($method === 'renderBlockParent' ? 'parent' : $item['args'][0]) . '}',
+							'file' => $object->getName(),
+							'line' => self::getSourceLine($item['file'], $item['line']),
+							'args' => self::filterParams($item['args'][1]),
+						];
+					}
+				}
+			} elseif ($object instanceof Engine) {
+				break;
+			}
+		}
+
+		return $res;
+	}
+
+
+	private static function getSourceLine(string $compiledFile, int $line): int
+	{
+		if (!is_file($compiledFile)) {
+			return 0;
+		}
+
+		$line = file($compiledFile)[$line - 1];
+		return preg_match('~/\* line (\d+) \*/~', $line, $m)
+			? (int) $m[1]
+			: 0;
+	}
+
+
+	private static function filterParams(array $params): array
+	{
+		foreach ($params as $key => $foo) {
+			if (is_string($key) && str_starts_with($key, 'ʟ_')) {
+				unset($params[$key]);
+			}
+		}
+
+		return $params;
+	}
+}

package/vendor/latte/latte/src/Latte/Essential/TranslatorExtension.php

@@ -0,0 +1,101 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Essential;
+
+use Latte;
+use Latte\Compiler\NodeHelpers;
+use Latte\Compiler\Nodes\Php;
+use Latte\Compiler\Tag;
+use Latte\Engine;
+use Latte\Essential\Nodes\PrintNode;
+use Nette\Localization\Translator;
+
+
+/**
+ * Extension for translations.
+ */
+final class TranslatorExtension extends Latte\Extension
+{
+	public function __construct(
+		private /*?callable|Translator*/ $translator,
+		private ?string $key = null,
+	) {
+		if ($translator instanceof Translator) {
+			$this->translator = [$translator, 'translate'];
+		}
+	}
+
+
+	public function getTags(): array
+	{
+		return [
+			'_' => [$this, 'parseTranslate'],
+			'translate' => fn(Tag $tag) => yield from Nodes\TranslateNode::create($tag, $this->key ? $this->translator : null),
+		];
+	}
+
+
+	public function getFilters(): array
+	{
+		return [
+			'translate' => fn(Latte\Runtime\FilterInfo $fi, ...$args): string => $this->translator
+				? ($this->translator)(...$args)
+				: $args[0],
+		];
+	}
+
+
+	public function getCacheKey(Engine $engine): mixed
+	{
+		return $this->key;
+	}
+
+
+	/**
+	 * {_ ...}
+	 */
+	public function parseTranslate(Tag $tag): PrintNode
+	{
+		$tag->outputMode = $tag::OutputKeepIndentation;
+		$tag->expectArguments();
+		$node = new PrintNode;
+		$node->expression = $tag->parser->parseUnquotedStringOrExpression();
+		$args = new Php\Expression\ArrayNode;
+		if ($tag->parser->stream->tryConsume(',')) {
+			$args = $tag->parser->parseArguments();
+		}
+
+		$node->modifier = $tag->parser->parseModifier();
+		$node->modifier->escape = true;
+
+		if ($this->translator
+			&& $this->key
+			&& ($expr = self::toValue($node->expression))
+			&& is_array($values = self::toValue($args))
+			&& is_string($translation = ($this->translator)($expr, ...$values))
+		) {
+			$node->expression = new Php\Scalar\StringNode($translation);
+			return $node;
+		}
+
+		array_unshift($node->modifier->filters, new Php\FilterNode(new Php\IdentifierNode('translate'), $args->toArguments()));
+		return $node;
+	}
+
+
+	public static function toValue($args): mixed
+	{
+		try {
+			return NodeHelpers::toValue($args, constants: true);
+		} catch (\InvalidArgumentException) {
+			return null;
+		}
+	}
+}

package/vendor/latte/latte/src/Latte/Extension.php

@@ -0,0 +1,97 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte;
+
+
+/**
+ * Latte extension.
+ */
+abstract class Extension
+{
+	/**
+	 * Initializes before template is compiler.
+	 */
+	public function beforeCompile(Engine $engine): void
+	{
+	}
+
+
+	/**
+	 * Returns a list of parsers for Latte tags.
+	 * @return array<string, callable(Compiler\Tag, Compiler\TemplateParser): (Compiler\Node|\Generator|void)|\stdClass>
+	 */
+	public function getTags(): array
+	{
+		return [];
+	}
+
+
+	/**
+	 * Returns a list of parsers for Latte tags.
+	 * @return array<string, callable(Compiler\Nodes\TemplateNode): void|\stdClass>
+	 */
+	public function getPasses(): array
+	{
+		return [];
+	}
+
+
+	/**
+	 * Returns a list of |filters.
+	 * @return array<string, callable>
+	 */
+	public function getFilters(): array
+	{
+		return [];
+	}
+
+
+	/**
+	 * Returns a list of functions used in templates.
+	 * @return array<string, callable>
+	 */
+	public function getFunctions(): array
+	{
+		return [];
+	}
+
+
+	/**
+	 * Returns a list of providers.
+	 * @return array<mixed>
+	 */
+	public function getProviders(): array
+	{
+		return [];
+	}
+
+
+	/**
+	 * Returns a value to distinguish multiple versions of the template.
+	 */
+	public function getCacheKey(Engine $engine): mixed
+	{
+		return null;
+	}
+
+
+	/**
+	 * Initializes before template is rendered.
+	 */
+	public function beforeRender(Engine $engine): void
+	{
+	}
+
+
+	public static function order(callable $subject, array|string $before = [], array|string $after = []): \stdClass
+	{
+		return (object) get_defined_vars();
+	}
+}

package/vendor/latte/latte/src/Latte/Helpers.php

@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte;
+
+
+/**
+ * Latte helpers.
+ * @internal
+ */
+class Helpers
+{
+	/** @var array<string, int>  empty (void) HTML elements */
+	public static array $emptyElements = [
+		'img' => 1, 'hr' => 1, 'br' => 1, 'input' => 1, 'meta' => 1, 'area' => 1, 'embed' => 1, 'keygen' => 1, 'source' => 1, 'base' => 1,
+		'col' => 1, 'link' => 1, 'param' => 1, 'basefont' => 1, 'frame' => 1, 'isindex' => 1, 'wbr' => 1, 'command' => 1, 'track' => 1,
+	];
+
+
+	/**
+	 * Finds the best suggestion.
+	 * @param  string[]  $items
+	 */
+	public static function getSuggestion(array $items, string $value): ?string
+	{
+		$best = null;
+		$min = (strlen($value) / 4 + 1) * 10 + .1;
+		foreach (array_unique($items) as $item) {
+			if (($len = levenshtein($item, $value, 10, 11, 10)) > 0 && $len < $min) {
+				$min = $len;
+				$best = $item;
+			}
+		}
+
+		return $best;
+	}
+
+
+	/** intentionally without callable typehint, because it generates bad error messages */
+	public static function toReflection($callable): \ReflectionFunctionAbstract
+	{
+		if (is_string($callable) && strpos($callable, '::')) {
+			return new \ReflectionMethod($callable);
+		} elseif (is_array($callable)) {
+			return new \ReflectionMethod($callable[0], $callable[1]);
+		} elseif (is_object($callable) && !$callable instanceof \Closure) {
+			return new \ReflectionMethod($callable, '__invoke');
+		} else {
+			return new \ReflectionFunction($callable);
+		}
+	}
+
+
+	public static function sortBeforeAfter(array $list): array
+	{
+		foreach ($list as $name => $info) {
+			if (!$info instanceof \stdClass || !($info->before ?? $info->after ?? null)) {
+				continue;
+			}
+
+			unset($list[$name]);
+			$names = array_keys($list);
+			$best = null;
+
+			foreach ((array) $info->before as $target) {
+				if ($target === '*') {
+					$best = 0;
+				} elseif (isset($list[$target])) {
+					$pos = array_search($target, $names, true);
+					$best = min($pos, $best ?? $pos);
+				}
+			}
+
+			foreach ((array) ($info->after ?? null) as $target) {
+				if ($target === '*') {
+					$best = count($names);
+				} elseif (isset($list[$target])) {
+					$pos = array_search($target, $names, true);
+					$best = max($pos + 1, $best);
+				}
+			}
+
+			$list = array_slice($list, 0, $best, true)
+				+ [$name => $info]
+				+ array_slice($list, $best, null, true);
+		}
+
+		return $list;
+	}
+}

package/vendor/latte/latte/src/Latte/Loader.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte;
+
+
+/**
+ * Template loader.
+ */
+interface Loader
+{
+	/**
+	 * Returns template source code.
+	 */
+	function getContent(string $name): string;
+
+	/**
+	 * Checks whether template is expired.
+	 */
+	function isExpired(string $name, int $time): bool;
+
+	/**
+	 * Returns referred template name.
+	 */
+	function getReferredName(string $name, string $referringName): string;
+
+	/**
+	 * Returns unique identifier for caching.
+	 */
+	function getUniqueId(string $name): string;
+}

package/vendor/latte/latte/src/Latte/Loaders/FileLoader.php

@@ -0,0 +1,95 @@
+<?php
+
+/**
+ * This file is part of the Latte (https://latte.nette.org)
+ * Copyright (c) 2008 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Loaders;
+
+use Latte;
+
+
+/**
+ * Template loader.
+ */
+class FileLoader implements Latte\Loader
+{
+	use Latte\Strict;
+
+	protected ?string $baseDir = null;
+
+
+	public function __construct(?string $baseDir = null)
+	{
+		$this->baseDir = $baseDir ? $this->normalizePath("$baseDir/") : null;
+	}
+
+
+	/**
+	 * Returns template source code.
+	 */
+	public function getContent(string $fileName): string
+	{
+		$file = $this->baseDir . $fileName;
+		if ($this->baseDir && !str_starts_with($this->normalizePath($file), $this->baseDir)) {
+			throw new Latte\RuntimeException("Template '$file' is not within the allowed path '{$this->baseDir}'.");
+
+		} elseif (!is_file($file)) {
+			throw new Latte\RuntimeException("Missing template file '$file'.");
+
+		} elseif ($this->isExpired($fileName, time())) {
+			if (@touch($file) === false) {
+				trigger_error("File's modification time is in the future. Cannot update it: " . error_get_last()['message'], E_USER_WARNING);
+			}
+		}
+
+		return file_get_contents($file);
+	}
+
+
+	public function isExpired(string $file, int $time): bool
+	{
+		$mtime = @filemtime($this->baseDir . $file); // @ - stat may fail
+		return !$mtime || $mtime > $time;
+	}
+
+
+	/**
+	 * Returns referred template name.
+	 */
+	public function getReferredName(string $file, string $referringFile): string
+	{
+		if ($this->baseDir || !preg_match('#/|\\\\|[a-z][a-z0-9+.-]*:#iA', $file)) {
+			$file = $this->normalizePath($referringFile . '/../' . $file);
+		}
+
+		return $file;
+	}
+
+
+	/**
+	 * Returns unique identifier for caching.
+	 */
+	public function getUniqueId(string $file): string
+	{
+		return $this->baseDir . strtr($file, '/', DIRECTORY_SEPARATOR);
+	}
+
+
+	protected static function normalizePath(string $path): string
+	{
+		$res = [];
+		foreach (explode('/', strtr($path, '\\', '/')) as $part) {
+			if ($part === '..' && $res && end($res) !== '..') {
+				array_pop($res);
+			} elseif ($part !== '.') {
+				$res[] = $part;
+			}
+		}
+
+		return implode(DIRECTORY_SEPARATOR, $res);
+	}
+}