@vituum/vite-plugin-latte 0.1.8

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

@@ -0,0 +1,160 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Latte\Essential;
+
+use Latte;
+use Latte\Runtime\Template;
+use Nette\PhpGenerator as Php;
+
+
+/**
+ * Generates blueprint of template class.
+ * @internal
+ */
+final class Blueprint
+{
+	use Latte\Strict;
+
+	public function printClass(Template $template, ?string $name = null): void
+	{
+		if (!class_exists(Php\ClassType::class)) {
+			throw new \LogicException('Nette PhpGenerator is required to print template, install package `nette/php-generator`.');
+		}
+
+		$name = $name ?: 'Template';
+		$namespace = new Php\PhpNamespace(Php\Helpers::extractNamespace($name));
+		$class = $namespace->addClass(Php\Helpers::extractShortName($name));
+
+		$this->addProperties($class, $template->getParameters());
+		$functions = array_diff_key((array) $template->global->fn, (new Latte\Essential\CoreExtension)->getFunctions());
+		$this->addFunctions($class, $functions);
+
+		$end = $this->printCanvas();
+		$this->printHeader('Native types');
+		$this->printCode((string) $namespace);
+		echo $end;
+	}
+
+
+	/**
+	 * @param  mixed[]  $vars
+	 */
+	public function printVars(array $vars): void
+	{
+		if (!class_exists(Php\Type::class)) {
+			throw new \LogicException('Nette PhpGenerator is required to print template, install package `nette/php-generator`.');
+		}
+
+		$res = '';
+		foreach ($vars as $name => $value) {
+			if (str_starts_with($name, 'ʟ_')) {
+				continue;
+			}
+
+			$type = Php\Type::getType($value) ?: 'mixed';
+			$res .= "{varType $type $$name}\n";
+		}
+
+		$end = $this->printCanvas();
+		$this->printHeader('varPrint');
+		$this->printCode($res ?: 'No variables', 'latte');
+		echo $end;
+	}
+
+
+	/**
+	 * @param  mixed[]  $props
+	 */
+	public function addProperties(Php\ClassType $class, array $props): void
+	{
+		foreach ($props as $name => $value) {
+			$type = Php\Type::getType($value);
+			$prop = $class->addProperty($name);
+			$prop->setType($type);
+		}
+	}
+
+
+	/**
+	 * @param  callable[]  $funcs
+	 */
+	public function addFunctions(Php\ClassType $class, array $funcs): void
+	{
+		foreach ($funcs as $name => $func) {
+			$method = (new Php\Factory)->fromCallable($func);
+			$type = $this->printType($method->getReturnType(), $method->isReturnNullable(), $class->getNamespace()) ?: 'mixed';
+			$class->addComment("@method $type $name" . $this->printParameters($method, $class->getNamespace()));
+		}
+	}
+
+
+	private function printType(?string $type, bool $nullable, ?Php\PhpNamespace $namespace): string
+	{
+		if ($type === null) {
+			return '';
+		}
+
+		if ($namespace) {
+			$type = $namespace->unresolveName($type);
+		}
+
+		if ($nullable && strcasecmp($type, 'mixed')) {
+			$type = str_contains($type, '|')
+				? $type . '|null'
+				: '?' . $type;
+		}
+
+		return $type;
+	}
+
+
+	public function printParameters(
+		Php\Closure|Php\GlobalFunction|Php\Method $function,
+		?Php\PhpNamespace $namespace = null,
+	): string {
+		$params = [];
+		$list = $function->getParameters();
+		foreach ($list as $param) {
+			$variadic = $function->isVariadic() && $param === end($list);
+			$params[] = ltrim($this->printType($param->getType(), $param->isNullable(), $namespace) . ' ')
+				. ($param->isReference() ? '&' : '')
+				. ($variadic ? '...' : '')
+				. '$' . $param->getName()
+				. ($param->hasDefaultValue() && !$variadic ? ' = ' . var_export($param->getDefaultValue(), true) : '');
+		}
+
+		return '(' . implode(', ', $params) . ')';
+	}
+
+
+	public function printCanvas(): string
+	{
+		echo '<script src="https://nette.github.io/resources/prism/prism.js"></script>';
+		echo '<link rel="stylesheet" href="https://nette.github.io/resources/prism/prism.css">';
+		echo "<div style='all:initial;position:fixed;overflow:auto;z-index:1000;left:0;right:0;top:0;bottom:0;color:black;background:white;padding:1em'>\n";
+		return "</div>\n";
+	}
+
+
+	public function printHeader(string $string): void
+	{
+		echo "<h1 style='all:initial;display:block;font-size:2em;margin:1em 0'>",
+			htmlspecialchars($string),
+			"</h1>\n";
+	}
+
+
+	public function printCode(string $code, string $lang = 'php'): void
+	{
+		echo '<pre><code class="language-', htmlspecialchars($lang), '">',
+			htmlspecialchars($code),
+			"</code></pre>\n";
+	}
+}

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

@@ -0,0 +1,232 @@
+<?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;
+
+
+/**
+ * Smarter caching iterator.
+ *
+ * @property-read bool $first
+ * @property-read bool $last
+ * @property-read bool $empty
+ * @property-read bool $odd
+ * @property-read bool $even
+ * @property-read int $counter
+ * @property-read int $counter0
+ * @property-read mixed $nextKey
+ * @property-read mixed $nextValue
+ * @property-read ?self $parent
+ * @internal
+ */
+class CachingIterator extends \CachingIterator implements \Countable
+{
+	use Latte\Strict;
+
+	private int $counter = 0;
+	private ?self $parent = null;
+
+
+	public function __construct(mixed $iterator, ?self $parent = null)
+	{
+		if (is_array($iterator) || $iterator instanceof \stdClass) {
+			$iterator = new \ArrayIterator($iterator);
+
+		} elseif ($iterator instanceof \IteratorAggregate) {
+			do {
+				$iterator = $iterator->getIterator();
+			} while (!$iterator instanceof \Iterator);
+		} elseif ($iterator instanceof \Traversable) {
+			if (!$iterator instanceof \Iterator) {
+				$iterator = new \IteratorIterator($iterator);
+			}
+		} else {
+			throw new \InvalidArgumentException(sprintf('Invalid argument passed to foreach; array or Traversable expected, %s given.', is_object($iterator) ? $iterator::class : gettype($iterator)));
+		}
+
+		parent::__construct($iterator, 0);
+		$this->parent = $parent;
+	}
+
+
+	/**
+	 * Is the current element the first one?
+	 */
+	public function isFirst(?int $width = null): bool
+	{
+		return $this->counter === 1 || ($width && $this->counter !== 0 && (($this->counter - 1) % $width) === 0);
+	}
+
+
+	/**
+	 * Is the current element the last one?
+	 */
+	public function isLast(?int $width = null): bool
+	{
+		return !$this->hasNext() || ($width && ($this->counter % $width) === 0);
+	}
+
+
+	/**
+	 * Is the iterator empty?
+	 */
+	public function isEmpty(): bool
+	{
+		return $this->counter === 0;
+	}
+
+
+	/**
+	 * Is the counter odd?
+	 */
+	public function isOdd(): bool
+	{
+		return $this->counter % 2 === 1;
+	}
+
+
+	/**
+	 * Is the counter even?
+	 */
+	public function isEven(): bool
+	{
+		return $this->counter % 2 === 0;
+	}
+
+
+	/**
+	 * Returns the 1-indexed counter.
+	 */
+	public function getCounter(): int
+	{
+		return $this->counter;
+	}
+
+
+	/**
+	 * Returns the 0-indexed counter.
+	 */
+	public function getCounter0(): int
+	{
+		return max(0, $this->counter - 1);
+	}
+
+
+	/**
+	 * Decrements counter.
+	 */
+	public function skipRound(): void
+	{
+		$this->counter = max($this->counter - 1, 0);
+	}
+
+
+	/**
+	 * Returns the counter as string
+	 */
+	public function __toString(): string
+	{
+		return (string) $this->counter;
+	}
+
+
+	/**
+	 * Returns the count of elements.
+	 */
+	public function count(): int
+	{
+		$inner = $this->getInnerIterator();
+		if ($inner instanceof \Countable) {
+			return $inner->count();
+
+		} else {
+			throw new \LogicException('Iterator is not countable.');
+		}
+	}
+
+
+	/**
+	 * Forwards to the next element.
+	 */
+	public function next(): void
+	{
+		parent::next();
+		if (parent::valid()) {
+			$this->counter++;
+		}
+	}
+
+
+	/**
+	 * Rewinds the Iterator.
+	 */
+	public function rewind(): void
+	{
+		parent::rewind();
+		$this->counter = parent::valid() ? 1 : 0;
+	}
+
+
+	/**
+	 * Returns the next key or null if position is not valid.
+	 */
+	public function getNextKey(): mixed
+	{
+		$iterator = $this->getInnerIterator();
+		return $iterator->valid() ? $iterator->key() : null;
+	}
+
+
+	/**
+	 * Returns the next element or null if position is not valid.
+	 */
+	public function getNextValue(): mixed
+	{
+		$iterator = $this->getInnerIterator();
+		return $iterator->valid() ? $iterator->current() : null;
+	}
+
+
+	/**
+	 * Returns the iterator surrounding the current one.
+	 */
+	public function getParent(): ?self
+	{
+		return $this->parent;
+	}
+
+
+	/********************* property accessor ****************d*g**/
+
+
+	/**
+	 * Returns property value.
+	 * @throws \LogicException if the property is not defined.
+	 */
+	public function &__get(string $name): mixed
+	{
+		if (method_exists($this, $m = 'get' . $name) || method_exists($this, $m = 'is' . $name)) {
+			$ret = $this->$m();
+			return $ret;
+		}
+
+		throw new \LogicException('Attempt to read undeclared property ' . static::class . "::\$$name.");
+	}
+
+
+	/**
+	 * Is property defined?
+	 */
+	public function __isset(string $name): bool
+	{
+		return method_exists($this, 'get' . $name) || method_exists($this, 'is' . $name);
+	}
+}

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

@@ -0,0 +1,232 @@
+<?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\Nodes\Php\Scalar;
+use Latte\Compiler\Nodes\TemplateNode;
+use Latte\Compiler\Nodes\TextNode;
+use Latte\Compiler\Tag;
+use Latte\Compiler\TemplateParser;
+use Latte\RuntimeException;
+use Nette;
+
+
+/**
+ * Basic tags and filters for Latte.
+ */
+final class CoreExtension extends Latte\Extension
+{
+	use Latte\Strict;
+
+	private array $functions;
+
+
+	public function beforeCompile(Latte\Engine $engine): void
+	{
+		$this->functions = $engine->getFunctions();
+	}
+
+
+	public function getTags(): array
+	{
+		return [
+			'embed' => [Nodes\EmbedNode::class, 'create'],
+			'define' => [Nodes\DefineNode::class, 'create'],
+			'block' => [Nodes\BlockNode::class, 'create'],
+			'layout' => [Nodes\ExtendsNode::class, 'create'],
+			'extends' => [Nodes\ExtendsNode::class, 'create'],
+			'import' => [Nodes\ImportNode::class, 'create'],
+			'include' => \Closure::fromCallable([$this, 'includeSplitter']),
+
+			'n:attr' => [Nodes\NAttrNode::class, 'create'],
+			'n:class' => [Nodes\NClassNode::class, 'create'],
+			'n:tag' => [Nodes\NTagNode::class, 'create'],
+
+			'parameters' => [Nodes\ParametersNode::class, 'create'],
+			'varType' => [Nodes\VarTypeNode::class, 'create'],
+			'varPrint' => [Nodes\VarPrintNode::class, 'create'],
+			'templateType' => [Nodes\TemplateTypeNode::class, 'create'],
+			'templatePrint' => [Nodes\TemplatePrintNode::class, 'create'],
+
+			'=' => [Nodes\PrintNode::class, 'create'],
+			'do' => [Nodes\DoNode::class, 'create'],
+			'php' => [Nodes\DoNode::class, 'create'], // obsolete
+			'contentType' => [Nodes\ContentTypeNode::class, 'create'],
+			'spaceless' => [Nodes\SpacelessNode::class, 'create'],
+			'capture' => [Nodes\CaptureNode::class, 'create'],
+			'l' => fn(Tag $tag) => new TextNode('{', $tag->position),
+			'r' => fn(Tag $tag) => new TextNode('}', $tag->position),
+			'syntax' => \Closure::fromCallable([$this, 'parseSyntax']),
+
+			'dump' => [Nodes\DumpNode::class, 'create'],
+			'debugbreak' => [Nodes\DebugbreakNode::class, 'create'],
+			'trace' => [Nodes\TraceNode::class, 'create'],
+
+			'var' => [Nodes\VarNode::class, 'create'],
+			'default' => [Nodes\VarNode::class, 'create'],
+
+			'try' => [Nodes\TryNode::class, 'create'],
+			'rollback' => [Nodes\RollbackNode::class, 'create'],
+
+			'foreach' => [Nodes\ForeachNode::class, 'create'],
+			'for' => [Nodes\ForNode::class, 'create'],
+			'while' => [Nodes\WhileNode::class, 'create'],
+			'iterateWhile' => [Nodes\IterateWhileNode::class, 'create'],
+			'sep' => [Nodes\FirstLastSepNode::class, 'create'],
+			'last' => [Nodes\FirstLastSepNode::class, 'create'],
+			'first' => [Nodes\FirstLastSepNode::class, 'create'],
+			'skipIf' => [Nodes\SkipNode::class, 'create'],
+			'breakIf' => [Nodes\SkipNode::class, 'create'],
+			'continueIf' => [Nodes\SkipNode::class, 'create'],
+
+			'if' => [Nodes\IfNode::class, 'create'],
+			'ifset' => [Nodes\IfNode::class, 'create'],
+			'ifchanged' => [Nodes\IfChangedNode::class, 'create'],
+			'n:ifcontent' => [Nodes\IfContentNode::class, 'create'],
+			'switch' => [Nodes\SwitchNode::class, 'create'],
+		];
+	}
+
+
+	public function getFilters(): array
+	{
+		return [
+			'batch' => [Filters::class, 'batch'],
+			'breakLines' => [Filters::class, 'breaklines'],
+			'breaklines' => [Filters::class, 'breaklines'],
+			'bytes' => [Filters::class, 'bytes'],
+			'capitalize' => extension_loaded('mbstring')
+				? [Filters::class, 'capitalize']
+				: function () { throw new RuntimeException('Filter |capitalize requires mbstring extension.'); },
+			'ceil' => [Filters::class, 'ceil'],
+			'clamp' => [Filters::class, 'clamp'],
+			'dataStream' => [Filters::class, 'dataStream'],
+			'datastream' => [Filters::class, 'dataStream'],
+			'date' => [Filters::class, 'date'],
+			'escapeCss' => [Latte\Runtime\Filters::class, 'escapeCss'],
+			'escapeHtml' => [Latte\Runtime\Filters::class, 'escapeHtml'],
+			'escapeHtmlComment' => [Latte\Runtime\Filters::class, 'escapeHtmlComment'],
+			'escapeICal' => [Latte\Runtime\Filters::class, 'escapeICal'],
+			'escapeJs' => [Latte\Runtime\Filters::class, 'escapeJs'],
+			'escapeUrl' => 'rawurlencode',
+			'escapeXml' => [Latte\Runtime\Filters::class, 'escapeXml'],
+			'explode' => [Filters::class, 'explode'],
+			'first' => [Filters::class, 'first'],
+			'firstUpper' => extension_loaded('mbstring')
+				? [Filters::class, 'firstUpper']
+				: function () { throw new RuntimeException('Filter |firstUpper requires mbstring extension.'); },
+			'floor' => [Filters::class, 'floor'],
+			'checkUrl' => [Latte\Runtime\Filters::class, 'safeUrl'],
+			'implode' => [Filters::class, 'implode'],
+			'indent' => [Filters::class, 'indent'],
+			'join' => [Filters::class, 'implode'],
+			'last' => [Filters::class, 'last'],
+			'length' => [Filters::class, 'length'],
+			'lower' => extension_loaded('mbstring')
+				? [Filters::class, 'lower']
+				: function () { throw new RuntimeException('Filter |lower requires mbstring extension.'); },
+			'number' => 'number_format',
+			'padLeft' => [Filters::class, 'padLeft'],
+			'padRight' => [Filters::class, 'padRight'],
+			'query' => [Filters::class, 'query'],
+			'random' => [Filters::class, 'random'],
+			'repeat' => [Filters::class, 'repeat'],
+			'replace' => [Filters::class, 'replace'],
+			'replaceRe' => [Filters::class, 'replaceRe'],
+			'replaceRE' => [Filters::class, 'replaceRe'],
+			'reverse' => [Filters::class, 'reverse'],
+			'round' => [Filters::class, 'round'],
+			'slice' => [Filters::class, 'slice'],
+			'sort' => [Filters::class, 'sort'],
+			'spaceless' => [Filters::class, 'strip'],
+			'split' => [Filters::class, 'explode'],
+			'strip' => [Filters::class, 'strip'], // obsolete
+			'stripHtml' => [Filters::class, 'stripHtml'],
+			'striphtml' => [Filters::class, 'stripHtml'],
+			'stripTags' => [Filters::class, 'stripTags'],
+			'striptags' => [Filters::class, 'stripTags'],
+			'substr' => [Filters::class, 'substring'],
+			'trim' => [Filters::class, 'trim'],
+			'truncate' => [Filters::class, 'truncate'],
+			'upper' => extension_loaded('mbstring')
+				? [Filters::class, 'upper']
+				: function () { throw new RuntimeException('Filter |upper requires mbstring extension.'); },
+			'webalize' => class_exists(Nette\Utils\Strings::class)
+				? [Nette\Utils\Strings::class, 'webalize']
+				: function () { throw new RuntimeException('Filter |webalize requires nette/utils package.'); },
+		];
+	}
+
+
+	public function getFunctions(): array
+	{
+		return [
+			'clamp' => [Filters::class, 'clamp'],
+			'divisibleBy' => [Filters::class, 'divisibleBy'],
+			'even' => [Filters::class, 'even'],
+			'first' => [Filters::class, 'first'],
+			'last' => [Filters::class, 'last'],
+			'odd' => [Filters::class, 'odd'],
+			'slice' => [Filters::class, 'slice'],
+		];
+	}
+
+
+	public function getPasses(): array
+	{
+		return [
+			'internalVariables' => [Passes::class, 'internalVariablesPass'],
+			'overwrittenVariables' => [Passes::class, 'overwrittenVariablesPass'],
+			'customFunctions' => fn(TemplateNode $node) => Passes::customFunctionsPass($node, $this->functions),
+			'moveTemplatePrintToHead' => [Passes::class, 'moveTemplatePrintToHeadPass'],
+		];
+	}
+
+
+	/**
+	 * {include [file] "file" [with blocks] [,] [params]}
+	 * {include [block] name [,] [params]}
+	 */
+	private function includeSplitter(Tag $tag, TemplateParser $parser): Nodes\IncludeBlockNode|Nodes\IncludeFileNode
+	{
+		$tag->expectArguments();
+		$mod = $tag->parser->tryConsumeModifier('block', 'file');
+		if ($mod) {
+			$block = $mod->text === 'block';
+		} elseif ($tag->parser->stream->tryConsume('#')) {
+			$block = true;
+		} else {
+			$name = $tag->parser->parseUnquotedStringOrExpression();
+			$block = $name instanceof Scalar\StringNode && preg_match('~[\w-]+$~DA', $name->value);
+		}
+		$tag->parser->stream->seek(0);
+
+		return $block
+			? Nodes\IncludeBlockNode::create($tag, $parser)
+			: Nodes\IncludeFileNode::create($tag);
+	}
+
+
+	/**
+	 * {syntax ...}
+	 */
+	private function parseSyntax(Tag $tag, TemplateParser $parser): \Generator
+	{
+		$tag->expectArguments();
+		$token = $tag->parser->stream->consume();
+		$lexer = $parser->getLexer();
+		$saved = [$lexer->openDelimiter, $lexer->closeDelimiter];
+		$lexer->setSyntax($token->text, $tag->isNAttribute() ? null : $tag->name);
+		[$inner] = yield;
+		[$lexer->openDelimiter, $lexer->closeDelimiter] = $saved;
+		return $inner;
+	}
+}