@vituum/vite-plugin-latte 1.1.0 → 1.2.1

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

@@ -9,71 +9,31 @@ declare(strict_types=1);
 
 namespace Latte\Essential;
 
-use Latte;
 use Latte\CompileException;
 use Latte\Compiler\Node;
-use Latte\Compiler\Nodes\AuxiliaryNode;
 use Latte\Compiler\Nodes\Php\Expression;
 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;
+use Latte\Engine;
 
 
 final class Passes
 {
-	/**
-	 * 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;
-			}
-		});
+	public function __construct(
+		private Engine $engine,
+	) {
 	}
 
 
 	/**
 	 * Enable custom functions.
 	 */
-	public static function customFunctionsPass(TemplateNode $node, array $functions): void
+	public function customFunctionsPass(TemplateNode $node): void
 	{
+		$functions = $this->engine->getFunctions();
 		$names = array_keys($functions);
 		$names = array_combine(array_map('strtolower', $names), $names);
 
@@ -87,7 +47,7 @@ final class Passes
 				}
 
 				return new Expression\AuxiliaryNode(
-					fn(PrintContext $context, ...$args) => '($this->global->fn->' . $orig . ')(' . $context->implode($args) . ')',
+					fn(PrintContext $context, ...$args) => '($this->global->fn->' . $orig . ')($this, ' . $context->implode($args) . ')',
 					$node->args,
 				);
 			}
@@ -96,11 +56,11 @@ final class Passes
 
 
 	/**
-	 * $ʟ_xxx variables are forbidden
+	 * $ʟ_xxx, $GLOBALS and $this are forbidden
 	 */
-	public static function internalVariablesPass(TemplateNode $node, bool $forbidThis = false): void
+	public function forbiddenVariablesPass(TemplateNode $node): void
 	{
-		$forbidden = $forbidThis ? ['GLOBALS', 'this'] : ['GLOBALS'];
+		$forbidden = $this->engine->isStrictParsing() ? ['GLOBALS', 'this'] : ['GLOBALS'];
 		(new NodeTraverser)->traverse($node, function (Node $node) use ($forbidden) {
 			if ($node instanceof VariableNode
 				&& is_string($node->name)

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

@@ -46,7 +46,9 @@ class Helpers
 	public static function toReflection($callable): \ReflectionFunctionAbstract
 	{
 		if (is_string($callable) && strpos($callable, '::')) {
-			return new \ReflectionMethod($callable);
+			return PHP_VERSION_ID < 80300
+				? new \ReflectionMethod($callable)
+				: \ReflectionMethod::createFromMethodName($callable);
 		} elseif (is_array($callable)) {
 			return new \ReflectionMethod($callable[0], $callable[1]);
 		} elseif (is_object($callable) && !$callable instanceof \Closure) {

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

@@ -22,6 +22,7 @@ interface Loader
 
 	/**
 	 * Checks whether template is expired.
+	 * @deprecated
 	 */
 	function isExpired(string $name, int $time): bool;
 

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

@@ -50,8 +50,7 @@ class FileLoader implements Latte\Loader
 
 	public function isExpired(string $file, int $time): bool
 	{
-		$mtime = @filemtime($this->baseDir . $file); // @ - stat may fail
-		return !$mtime || $mtime > $time;
+		return false;
 	}
 
 

package/vendor/latte/latte/src/Latte/Runtime/Filters.php

@@ -24,9 +24,6 @@ class Filters
 	/** @deprecated */
 	public static string $dateFormat = "j.\u{a0}n.\u{a0}Y";
 
-	/** @internal use XML syntax? */
-	public static bool $xml = false;
-
 
 	/**
 	 * Escapes string for use everywhere inside HTML (except for comments).
@@ -259,7 +256,7 @@ class Filters
 	/**
 	 * Sanitizes string for use inside href attribute.
 	 */
-	public static function safeUrl(string|\Stringable $s): string
+	public static function safeUrl($s): string
 	{
 		$s = $s instanceof HtmlStringable
 			? self::convertHtmlToText((string) $s)

package/vendor/latte/latte/src/Latte/Runtime/FunctionExecutor.php

@@ -0,0 +1,68 @@
+<?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\Runtime;
+
+use Latte\Helpers;
+
+
+/**
+ * Functions executor.
+ * @internal
+ */
+#[\AllowDynamicProperties]
+class FunctionExecutor
+{
+	/** @var callable[] */
+	private array $_list = [];
+
+	/** @var bool[] */
+	private array $_aware = [];
+
+
+	/**
+	 * Registers run-time function.
+	 */
+	public function add(string $name, callable $callback): static
+	{
+		$this->_list[$name] = $callback;
+		unset($this->$name, $this->_aware[$name]);
+		return $this;
+	}
+
+
+	/**
+	 * Returns all run-time functions.
+	 * @return callable[]
+	 */
+	public function getAll(): array
+	{
+		return $this->_list;
+	}
+
+
+	public function __get(string $name): callable
+	{
+		$callback = $this->_list[$name] ?? null;
+		if (!$callback) {
+			$hint = ($t = Helpers::getSuggestion(array_keys($this->_list), $name))
+				? ", did you mean '$t'?"
+				: '.';
+			throw new \LogicException("Function '$name' is not defined$hint");
+
+		} elseif (!isset($this->_aware[$name])) {
+			$params = Helpers::toReflection($callback)->getParameters();
+			$this->_aware[$name] = $params && (string) $params[0]->getType() === Template::class;
+		}
+
+		return $this->$name = $this->_aware[$name]
+			? $callback
+			: fn($info, ...$args) => $callback(...$args);
+	}
+}

package/vendor/latte/latte/src/Latte/Runtime/Template.php

@@ -142,8 +142,6 @@ class Template
 			$this->parentName = ($this->global->coreParentFinder)($this);
 		}
 
-		Filters::$xml = static::ContentType === Latte\ContentType::Xml;
-
 		if ($this->referenceType === 'import') {
 			if ($this->parentName) {
 				throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
@@ -172,7 +170,7 @@ class Template
 		$name = $this->engine->getLoader()->getReferredName($name, $this->name);
 		$referred = $referenceType === 'sandbox'
 			? (clone $this->engine)->setSandboxMode()->createTemplate($name, $params)
-			: $this->engine->createTemplate($name, $params);
+			: $this->engine->createTemplate($name, $params, clearCache: false);
 
 		$referred->referringTemplate = $this;
 		$referred->referenceType = $referenceType;

package/vendor/nette/utils/.phpstorm.meta.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PHPSTORM_META;
+
+override(\Nette\Utils\Arrays::get(0), elementType(0));
+override(\Nette\Utils\Arrays::getRef(0), elementType(0));
+override(\Nette\Utils\Arrays::grep(0), type(0));
+override(\Nette\Utils\Arrays::toObject(0), type(1));
+
+expectedArguments(\Nette\Utils\Image::resize(), 2, \Nette\Utils\Image::ShrinkOnly, \Nette\Utils\Image::Stretch, \Nette\Utils\Image::OrSmaller, \Nette\Utils\Image::OrBigger, \Nette\Utils\Image::Cover);
+expectedArguments(\Nette\Utils\Image::calculateSize(), 4, \Nette\Utils\Image::ShrinkOnly, \Nette\Utils\Image::Stretch, \Nette\Utils\Image::OrSmaller, \Nette\Utils\Image::OrBigger, \Nette\Utils\Image::Cover);

package/vendor/nette/utils/composer.json

@@ -0,0 +1,51 @@
+{
+	"name": "nette/utils",
+	"description": "🛠  Nette Utils: lightweight utilities for string & array manipulation, image handling, safe JSON encoding/decoding, validation, slug or strong password generating etc.",
+	"keywords": ["nette", "images", "json", "password", "validation", "utility", "string", "array", "core", "slugify", "utf-8", "unicode", "paginator", "datetime"],
+	"homepage": "https://nette.org",
+	"license": ["BSD-3-Clause", "GPL-2.0-only", "GPL-3.0-only"],
+	"authors": [
+		{
+			"name": "David Grudl",
+			"homepage": "https://davidgrudl.com"
+		},
+		{
+			"name": "Nette Community",
+			"homepage": "https://nette.org/contributors"
+		}
+	],
+	"require": {
+		"php": ">=8.0 <8.4"
+	},
+	"require-dev": {
+		"nette/tester": "^2.5",
+		"tracy/tracy": "^2.9",
+		"phpstan/phpstan": "^1.0",
+		"jetbrains/phpstorm-attributes": "dev-master"
+	},
+	"conflict": {
+		"nette/finder": "<3",
+		"nette/schema": "<1.2.2"
+	},
+	"suggest": {
+		"ext-iconv": "to use Strings::webalize(), toAscii(), chr() and reverse()",
+		"ext-json": "to use Nette\\Utils\\Json",
+		"ext-intl": "to use Strings::webalize(), toAscii(), normalize() and compare()",
+		"ext-mbstring": "to use Strings::lower() etc...",
+		"ext-gd": "to use Image",
+		"ext-tokenizer": "to use Nette\\Utils\\Reflection::getUseStatements()"
+	},
+	"autoload": {
+		"classmap": ["src/"]
+	},
+	"minimum-stability": "dev",
+	"scripts": {
+		"phpstan": "phpstan analyse",
+		"tester": "tester tests -s"
+	},
+	"extra": {
+		"branch-alias": {
+			"dev-master": "4.0-dev"
+		}
+	}
+}

package/vendor/nette/utils/license.md

@@ -0,0 +1,60 @@
+Licenses
+========
+
+Good news! You may use Nette Framework under the terms of either
+the New BSD License or the GNU General Public License (GPL) version 2 or 3.
+
+The BSD License is recommended for most projects. It is easy to understand and it
+places almost no restrictions on what you can do with the framework. If the GPL
+fits better to your project, you can use the framework under this license.
+
+You don't have to notify anyone which license you are using. You can freely
+use Nette Framework in commercial projects as long as the copyright header
+remains intact.
+
+Please be advised that the name "Nette Framework" is a protected trademark and its
+usage has some limitations. So please do not use word "Nette" in the name of your
+project or top-level domain, and choose a name that stands on its own merits.
+If your stuff is good, it will not take long to establish a reputation for yourselves.
+
+
+New BSD License
+---------------
+
+Copyright (c) 2004, 2014 David Grudl (https://davidgrudl.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright notice,
+	this list of conditions and the following disclaimer.
+
+	* Redistributions in binary form must reproduce the above copyright notice,
+	this list of conditions and the following disclaimer in the documentation
+	and/or other materials provided with the distribution.
+
+	* Neither the name of "Nette Framework" nor the names of its contributors
+	may be used to endorse or promote products derived from this software
+	without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall the copyright owner or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused and on
+any theory of liability, whether in contract, strict liability, or tort
+(including negligence or otherwise) arising in any way out of the use of this
+software, even if advised of the possibility of such damage.
+
+
+GNU General Public License
+--------------------------
+
+GPL licenses are very very long, so instead of including them here we offer
+you URLs with full text:
+
+- [GPL version 2](http://www.gnu.org/licenses/gpl-2.0.html)
+- [GPL version 3](http://www.gnu.org/licenses/gpl-3.0.html)

package/vendor/nette/utils/readme.md

@@ -0,0 +1,56 @@
+Nette Utility Classes
+=====================
+
+[![Downloads this Month](https://img.shields.io/packagist/dm/nette/utils.svg)](https://packagist.org/packages/nette/utils)
+[![Tests](https://github.com/nette/utils/workflows/Tests/badge.svg?branch=master)](https://github.com/nette/utils/actions)
+[![Coverage Status](https://coveralls.io/repos/github/nette/utils/badge.svg?branch=master)](https://coveralls.io/github/nette/utils?branch=master)
+[![Latest Stable Version](https://poser.pugx.org/nette/utils/v/stable)](https://github.com/nette/utils/releases)
+[![License](https://img.shields.io/badge/license-New%20BSD-blue.svg)](https://github.com/nette/utils/blob/master/license.md)
+
+
+Introduction
+------------
+
+In package nette/utils you will find a set of [useful classes](https://doc.nette.org/utils) for everyday use:
+
+- [Arrays](https://doc.nette.org/utils/arrays) - manipulate arrays
+- [Callback](https://doc.nette.org/utils/callback) - PHP callbacks
+- [Date and Time](https://doc.nette.org/utils/datetime) - modify times and dates
+- [Filesystem](https://doc.nette.org/utils/filesystem) - copying, renaming, …
+- [Finder](https://doc.nette.org/utils/finder) - finds files and directories
+- [Helper Functions](https://doc.nette.org/utils/helpers)
+- [HTML elements](https://doc.nette.org/utils/html-elements) - generate HTML
+- [Images](https://doc.nette.org/utils/images) - crop, resize, rotate images
+- [JSON](https://doc.nette.org/utils/json) - encoding and decoding
+- [Generating Random Strings](https://doc.nette.org/utils/random)
+- [Paginator](https://doc.nette.org/utils/paginator) - pagination math
+- [PHP Reflection](https://doc.nette.org/utils/reflection)
+- [Strings](https://doc.nette.org/utils/strings) - useful text functions
+- [SmartObject](https://doc.nette.org/utils/smartobject) - PHP object enhancements
+- [Validation](https://doc.nette.org/utils/validators) - validate inputs
+- [Type](https://doc.nette.org/utils/type) - PHP data type
+
+
+Installation
+------------
+
+The recommended way to install is via Composer:
+
+```
+composer require nette/utils
+```
+
+- Nette Utils 4.0 is compatible with PHP 8.0 to 8.3
+- Nette Utils 3.2 is compatible with PHP 7.2 to 8.3
+- Nette Utils 3.1 is compatible with PHP 7.1 to 8.0
+- Nette Utils 3.0 is compatible with PHP 7.1 to 8.0
+- Nette Utils 2.5 is compatible with PHP 5.6 to 8.0
+
+[Support Me](https://github.com/sponsors/dg)
+--------------------------------------------
+
+Do you like Nette Utils? Are you looking forward to the new features?
+
+[![Buy me a coffee](https://files.nette.org/icons/donation-3.svg)](https://github.com/sponsors/dg)
+
+Thank you!

package/vendor/nette/utils/src/HtmlStringable.php

@@ -0,0 +1,22 @@
+<?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 Nette;
+
+
+interface HtmlStringable
+{
+	/**
+	 * Returns string in HTML format
+	 */
+	function __toString(): string;
+}
+
+
+interface_exists(Utils\IHtmlString::class);

package/vendor/nette/utils/src/Iterators/CachingIterator.php

@@ -0,0 +1,164 @@
+<?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 Nette\Iterators;
+
+use Nette;
+
+
+/**
+ * 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 mixed $nextKey
+ * @property-read mixed $nextValue
+ */
+class CachingIterator extends \CachingIterator implements \Countable
+{
+	use Nette\SmartObject;
+
+	private int $counter = 0;
+
+
+	public function __construct($iterator)
+	{
+		if (is_array($iterator) || $iterator instanceof \stdClass) {
+			$iterator = new \ArrayIterator($iterator);
+
+		} elseif ($iterator instanceof \IteratorAggregate) {
+			do {
+				$iterator = $iterator->getIterator();
+			} while ($iterator instanceof \IteratorAggregate);
+
+			assert($iterator instanceof \Iterator);
+
+		} elseif ($iterator instanceof \Iterator) {
+		} elseif ($iterator instanceof \Traversable) {
+			$iterator = new \IteratorIterator($iterator);
+		} else {
+			throw new Nette\InvalidArgumentException(sprintf('Invalid argument passed to %s; array or Traversable expected, %s given.', self::class, get_debug_type($iterator)));
+		}
+
+		parent::__construct($iterator, 0);
+	}
+
+
+	/**
+	 * Is the current element the first one?
+	 */
+	public function isFirst(?int $gridWidth = null): bool
+	{
+		return $this->counter === 1 || ($gridWidth && $this->counter !== 0 && (($this->counter - 1) % $gridWidth) === 0);
+	}
+
+
+	/**
+	 * Is the current element the last one?
+	 */
+	public function isLast(?int $gridWidth = null): bool
+	{
+		return !$this->hasNext() || ($gridWidth && ($this->counter % $gridWidth) === 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 counter.
+	 */
+	public function getCounter(): int
+	{
+		return $this->counter;
+	}
+
+
+	/**
+	 * Returns the count of elements.
+	 */
+	public function count(): int
+	{
+		$inner = $this->getInnerIterator();
+		if ($inner instanceof \Countable) {
+			return $inner->count();
+
+		} else {
+			throw new Nette\NotSupportedException('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.
+	 */
+	public function getNextKey(): mixed
+	{
+		return $this->getInnerIterator()->key();
+	}
+
+
+	/**
+	 * Returns the next element.
+	 */
+	public function getNextValue(): mixed
+	{
+		return $this->getInnerIterator()->current();
+	}
+}

package/vendor/nette/utils/src/Iterators/Mapper.php

@@ -0,0 +1,34 @@
+<?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 Nette\Iterators;
+
+
+
+/**
+ * Applies the callback to the elements of the inner iterator.
+ */
+class Mapper extends \IteratorIterator
+{
+	/** @var callable */
+	private $callback;
+
+
+	public function __construct(\Traversable $iterator, callable $callback)
+	{
+		parent::__construct($iterator);
+		$this->callback = $callback;
+	}
+
+
+	public function current(): mixed
+	{
+		return ($this->callback)(parent::current(), parent::key());
+	}
+}