@vituum/vite-plugin-latte 1.2.0 → 1.3.0

package/vendor/nette/utils/src/Utils/Finder.php

@@ -0,0 +1,510 @@
+<?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\Utils;
+
+use Nette;
+
+
+/**
+ * Finder allows searching through directory trees using iterator.
+ *
+ * Finder::findFiles('*.php')
+ *     ->size('> 10kB')
+ *     ->from('.')
+ *     ->exclude('temp');
+ *
+ * @implements \IteratorAggregate<string, FileInfo>
+ */
+class Finder implements \IteratorAggregate
+{
+	use Nette\SmartObject;
+
+	/** @var array<array{string, string}> */
+	private array $find = [];
+
+	/** @var string[] */
+	private array $in = [];
+
+	/** @var \Closure[] */
+	private array $filters = [];
+
+	/** @var \Closure[] */
+	private array $descentFilters = [];
+
+	/** @var array<string|self> */
+	private array $appends = [];
+	private bool $childFirst = false;
+
+	/** @var ?callable */
+	private $sort;
+	private int $maxDepth = -1;
+	private bool $ignoreUnreadableDirs = true;
+
+
+	/**
+	 * Begins search for files and directories matching mask.
+	 */
+	public static function find(string|array $masks = ['*']): static
+	{
+		$masks = is_array($masks) ? $masks : func_get_args(); // compatibility with variadic
+		return (new static)->addMask($masks, 'dir')->addMask($masks, 'file');
+	}
+
+
+	/**
+	 * Begins search for files matching mask.
+	 */
+	public static function findFiles(string|array $masks = ['*']): static
+	{
+		$masks = is_array($masks) ? $masks : func_get_args(); // compatibility with variadic
+		return (new static)->addMask($masks, 'file');
+	}
+
+
+	/**
+	 * Begins search for directories matching mask.
+	 */
+	public static function findDirectories(string|array $masks = ['*']): static
+	{
+		$masks = is_array($masks) ? $masks : func_get_args(); // compatibility with variadic
+		return (new static)->addMask($masks, 'dir');
+	}
+
+
+	/**
+	 * Finds files matching the specified masks.
+	 */
+	public function files(string|array $masks = ['*']): static
+	{
+		return $this->addMask((array) $masks, 'file');
+	}
+
+
+	/**
+	 * Finds directories matching the specified masks.
+	 */
+	public function directories(string|array $masks = ['*']): static
+	{
+		return $this->addMask((array) $masks, 'dir');
+	}
+
+
+	private function addMask(array $masks, string $mode): static
+	{
+		foreach ($masks as $mask) {
+			$mask = FileSystem::unixSlashes($mask);
+			if ($mode === 'dir') {
+				$mask = rtrim($mask, '/');
+			}
+			if ($mask === '' || ($mode === 'file' && str_ends_with($mask, '/'))) {
+				throw new Nette\InvalidArgumentException("Invalid mask '$mask'");
+			}
+			if (str_starts_with($mask, '**/')) {
+				$mask = substr($mask, 3);
+			}
+			$this->find[] = [$mask, $mode];
+		}
+		return $this;
+	}
+
+
+	/**
+	 * Searches in the given directories. Wildcards are allowed.
+	 */
+	public function in(string|array $paths): static
+	{
+		$paths = is_array($paths) ? $paths : func_get_args(); // compatibility with variadic
+		$this->addLocation($paths, '');
+		return $this;
+	}
+
+
+	/**
+	 * Searches recursively from the given directories. Wildcards are allowed.
+	 */
+	public function from(string|array $paths): static
+	{
+		$paths = is_array($paths) ? $paths : func_get_args(); // compatibility with variadic
+		$this->addLocation($paths, '/**');
+		return $this;
+	}
+
+
+	private function addLocation(array $paths, string $ext): void
+	{
+		foreach ($paths as $path) {
+			if ($path === '') {
+				throw new Nette\InvalidArgumentException("Invalid directory '$path'");
+			}
+			$path = rtrim(FileSystem::unixSlashes($path), '/');
+			$this->in[] = $path . $ext;
+		}
+	}
+
+
+	/**
+	 * Lists directory's contents before the directory itself. By default, this is disabled.
+	 */
+	public function childFirst(bool $state = true): static
+	{
+		$this->childFirst = $state;
+		return $this;
+	}
+
+
+	/**
+	 * Ignores unreadable directories. By default, this is enabled.
+	 */
+	public function ignoreUnreadableDirs(bool $state = true): static
+	{
+		$this->ignoreUnreadableDirs = $state;
+		return $this;
+	}
+
+
+	/**
+	 * Set a compare function for sorting directory entries. The function will be called to sort entries from the same directory.
+	 * @param  callable(FileInfo, FileInfo): int  $callback
+	 */
+	public function sortBy(callable $callback): static
+	{
+		$this->sort = $callback;
+		return $this;
+	}
+
+
+	/**
+	 * Sorts files in each directory naturally by name.
+	 */
+	public function sortByName(): static
+	{
+		$this->sort = fn(FileInfo $a, FileInfo $b): int => strnatcmp($a->getBasename(), $b->getBasename());
+		return $this;
+	}
+
+
+	/**
+	 * Adds the specified paths or appends a new finder that returns.
+	 */
+	public function append(string|array|null $paths = null): static
+	{
+		if ($paths === null) {
+			return $this->appends[] = new static;
+		}
+
+		$this->appends = array_merge($this->appends, (array) $paths);
+		return $this;
+	}
+
+
+	/********************* filtering ****************d*g**/
+
+
+	/**
+	 * Skips entries that matches the given masks relative to the ones defined with the in() or from() methods.
+	 */
+	public function exclude(string|array $masks): static
+	{
+		$masks = is_array($masks) ? $masks : func_get_args(); // compatibility with variadic
+		foreach ($masks as $mask) {
+			$mask = FileSystem::unixSlashes($mask);
+			if (!preg_match('~^/?(\*\*/)?(.+)(/\*\*|/\*|/|)$~D', $mask, $m)) {
+				throw new Nette\InvalidArgumentException("Invalid mask '$mask'");
+			}
+			$end = $m[3];
+			$re = $this->buildPattern($m[2]);
+			$filter = fn(FileInfo $file): bool => ($end && !$file->isDir())
+				|| !preg_match($re, FileSystem::unixSlashes($file->getRelativePathname()));
+
+			$this->descentFilter($filter);
+			if ($end !== '/*') {
+				$this->filter($filter);
+			}
+		}
+
+		return $this;
+	}
+
+
+	/**
+	 * Yields only entries which satisfy the given filter.
+	 * @param  callable(FileInfo): bool  $callback
+	 */
+	public function filter(callable $callback): static
+	{
+		$this->filters[] = \Closure::fromCallable($callback);
+		return $this;
+	}
+
+
+	/**
+	 * It descends only to directories that match the specified filter.
+	 * @param  callable(FileInfo): bool  $callback
+	 */
+	public function descentFilter(callable $callback): static
+	{
+		$this->descentFilters[] = \Closure::fromCallable($callback);
+		return $this;
+	}
+
+
+	/**
+	 * Sets the maximum depth of entries.
+	 */
+	public function limitDepth(?int $depth): static
+	{
+		$this->maxDepth = $depth ?? -1;
+		return $this;
+	}
+
+
+	/**
+	 * Restricts the search by size. $operator accepts "[operator] [size] [unit]" example: >=10kB
+	 */
+	public function size(string $operator, ?int $size = null): static
+	{
+		if (func_num_args() === 1) { // in $operator is predicate
+			if (!preg_match('#^(?:([=<>!]=?|<>)\s*)?((?:\d*\.)?\d+)\s*(K|M|G|)B?$#Di', $operator, $matches)) {
+				throw new Nette\InvalidArgumentException('Invalid size predicate format.');
+			}
+
+			[, $operator, $size, $unit] = $matches;
+			$units = ['' => 1, 'k' => 1e3, 'm' => 1e6, 'g' => 1e9];
+			$size *= $units[strtolower($unit)];
+			$operator = $operator ?: '=';
+		}
+
+		return $this->filter(fn(FileInfo $file): bool => !$file->isFile() || Helpers::compare($file->getSize(), $operator, $size));
+	}
+
+
+	/**
+	 * Restricts the search by modified time. $operator accepts "[operator] [date]" example: >1978-01-23
+	 */
+	public function date(string $operator, string|int|\DateTimeInterface|null $date = null): static
+	{
+		if (func_num_args() === 1) { // in $operator is predicate
+			if (!preg_match('#^(?:([=<>!]=?|<>)\s*)?(.+)$#Di', $operator, $matches)) {
+				throw new Nette\InvalidArgumentException('Invalid date predicate format.');
+			}
+
+			[, $operator, $date] = $matches;
+			$operator = $operator ?: '=';
+		}
+
+		$date = DateTime::from($date)->format('U');
+		return $this->filter(fn(FileInfo $file): bool => !$file->isFile() || Helpers::compare($file->getMTime(), $operator, $date));
+	}
+
+
+	/********************* iterator generator ****************d*g**/
+
+
+	/**
+	 * Returns an array with all found files and directories.
+	 * @return list<FileInfo>
+	 */
+	public function collect(): array
+	{
+		return iterator_to_array($this->getIterator(), preserve_keys: false);
+	}
+
+
+	/** @return \Generator<string, FileInfo> */
+	public function getIterator(): \Generator
+	{
+		$plan = $this->buildPlan();
+		foreach ($plan as $dir => $searches) {
+			yield from $this->traverseDir($dir, $searches);
+		}
+
+		foreach ($this->appends as $item) {
+			if ($item instanceof self) {
+				yield from $item->getIterator();
+			} else {
+				$item = FileSystem::platformSlashes($item);
+				yield $item => new FileInfo($item);
+			}
+		}
+	}
+
+
+	/**
+	 * @param  array<object{pattern: string, mode: string, recursive: bool}>  $searches
+	 * @param  string[]  $subdirs
+	 * @return \Generator<string, FileInfo>
+	 */
+	private function traverseDir(string $dir, array $searches, array $subdirs = []): \Generator
+	{
+		if ($this->maxDepth >= 0 && count($subdirs) > $this->maxDepth) {
+			return;
+		} elseif (!is_dir($dir)) {
+			throw new Nette\InvalidStateException(sprintf("Directory '%s' does not exist.", rtrim($dir, '/\\')));
+		}
+
+		try {
+			$pathNames = new \FilesystemIterator($dir, \FilesystemIterator::FOLLOW_SYMLINKS | \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::CURRENT_AS_PATHNAME | \FilesystemIterator::UNIX_PATHS);
+		} catch (\UnexpectedValueException $e) {
+			if ($this->ignoreUnreadableDirs) {
+				return;
+			} else {
+				throw new Nette\InvalidStateException($e->getMessage());
+			}
+		}
+
+		$files = $this->convertToFiles($pathNames, implode('/', $subdirs), FileSystem::isAbsolute($dir));
+
+		if ($this->sort) {
+			$files = iterator_to_array($files);
+			usort($files, $this->sort);
+		}
+
+		foreach ($files as $file) {
+			$pathName = $file->getPathname();
+			$cache = $subSearch = [];
+
+			if ($file->isDir()) {
+				foreach ($searches as $search) {
+					if ($search->recursive && $this->proveFilters($this->descentFilters, $file, $cache)) {
+						$subSearch[] = $search;
+					}
+				}
+			}
+
+			if ($this->childFirst && $subSearch) {
+				yield from $this->traverseDir($pathName, $subSearch, array_merge($subdirs, [$file->getBasename()]));
+			}
+
+			$relativePathname = FileSystem::unixSlashes($file->getRelativePathname());
+			foreach ($searches as $search) {
+				if (
+					$file->{'is' . $search->mode}()
+					&& preg_match($search->pattern, $relativePathname)
+					&& $this->proveFilters($this->filters, $file, $cache)
+				) {
+					yield $pathName => $file;
+					break;
+				}
+			}
+
+			if (!$this->childFirst && $subSearch) {
+				yield from $this->traverseDir($pathName, $subSearch, array_merge($subdirs, [$file->getBasename()]));
+			}
+		}
+	}
+
+
+	private function convertToFiles(iterable $pathNames, string $relativePath, bool $absolute): \Generator
+	{
+		foreach ($pathNames as $pathName) {
+			if (!$absolute) {
+				$pathName = preg_replace('~\.?/~A', '', $pathName);
+			}
+			$pathName = FileSystem::platformSlashes($pathName);
+			yield new FileInfo($pathName, $relativePath);
+		}
+	}
+
+
+	private function proveFilters(array $filters, FileInfo $file, array &$cache): bool
+	{
+		foreach ($filters as $filter) {
+			$res = &$cache[spl_object_id($filter)];
+			$res ??= $filter($file);
+			if (!$res) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+
+	/** @return array<string, array<object{pattern: string, mode: string, recursive: bool}>> */
+	private function buildPlan(): array
+	{
+		$plan = $dirCache = [];
+		foreach ($this->find as [$mask, $mode]) {
+			$splits = [];
+			if (FileSystem::isAbsolute($mask)) {
+				if ($this->in) {
+					throw new Nette\InvalidStateException("You cannot combine the absolute path in the mask '$mask' and the directory to search '{$this->in[0]}'.");
+				}
+				$splits[] = self::splitRecursivePart($mask);
+			} else {
+				foreach ($this->in ?: ['.'] as $in) {
+					$in = strtr($in, ['[' => '[[]', ']' => '[]]']); // in path, do not treat [ and ] as a pattern by glob()
+					$splits[] = self::splitRecursivePart($in . '/' . $mask);
+				}
+			}
+
+			foreach ($splits as [$base, $rest, $recursive]) {
+				$base = $base === '' ? '.' : $base;
+				$dirs = $dirCache[$base] ??= strpbrk($base, '*?[')
+					? glob($base, GLOB_NOSORT | GLOB_ONLYDIR | GLOB_NOESCAPE)
+					: [strtr($base, ['[[]' => '[', '[]]' => ']'])]; // unescape [ and ]
+
+				if (!$dirs) {
+					throw new Nette\InvalidStateException(sprintf("Directory '%s' does not exist.", rtrim($base, '/\\')));
+				}
+
+				$search = (object) ['pattern' => $this->buildPattern($rest), 'mode' => $mode, 'recursive' => $recursive];
+				foreach ($dirs as $dir) {
+					$plan[$dir][] = $search;
+				}
+			}
+		}
+
+		return $plan;
+	}
+
+
+	/**
+	 * Since glob() does not know ** wildcard, we divide the path into a part for glob and a part for manual traversal.
+	 */
+	private static function splitRecursivePart(string $path): array
+	{
+		$a = strrpos($path, '/');
+		$parts = preg_split('~(?<=^|/)\*\*($|/)~', substr($path, 0, $a + 1), 2);
+		return isset($parts[1])
+			? [$parts[0], $parts[1] . substr($path, $a + 1), true]
+			: [$parts[0], substr($path, $a + 1), false];
+	}
+
+
+	/**
+	 * Converts wildcards to regular expression.
+	 */
+	private function buildPattern(string $mask): string
+	{
+		if ($mask === '*') {
+			return '##';
+		} elseif (str_starts_with($mask, './')) {
+			$anchor = '^';
+			$mask = substr($mask, 2);
+		} else {
+			$anchor = '(?:^|/)';
+		}
+
+		$pattern = strtr(
+			preg_quote($mask, '#'),
+			[
+				'\*\*/' => '(.+/)?',
+				'\*' => '[^/]*',
+				'\?' => '[^/]',
+				'\[\!' => '[^',
+				'\[' => '[',
+				'\]' => ']',
+				'\-' => '-',
+			],
+		);
+		return '#' . $anchor . $pattern . '$#D' . (defined('PHP_WINDOWS_VERSION_BUILD') ? 'i' : '');
+	}
+}

package/vendor/nette/utils/src/Utils/Floats.php

@@ -0,0 +1,107 @@
+<?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\Utils;
+
+use Nette;
+
+
+/**
+ * Floating-point numbers comparison.
+ */
+class Floats
+{
+	use Nette\StaticClass;
+
+	private const Epsilon = 1e-10;
+
+
+	public static function isZero(float $value): bool
+	{
+		return abs($value) < self::Epsilon;
+	}
+
+
+	public static function isInteger(float $value): bool
+	{
+		return abs(round($value) - $value) < self::Epsilon;
+	}
+
+
+	/**
+	 * Compare two floats. If $a < $b it returns -1, if they are equal it returns 0 and if $a > $b it returns 1
+	 * @throws \LogicException if one of parameters is NAN
+	 */
+	public static function compare(float $a, float $b): int
+	{
+		if (is_nan($a) || is_nan($b)) {
+			throw new \LogicException('Trying to compare NAN');
+
+		} elseif (!is_finite($a) && !is_finite($b) && $a === $b) {
+			return 0;
+		}
+
+		$diff = abs($a - $b);
+		if (($diff < self::Epsilon || ($diff / max(abs($a), abs($b)) < self::Epsilon))) {
+			return 0;
+		}
+
+		return $a < $b ? -1 : 1;
+	}
+
+
+	/**
+	 * Returns true if $a = $b
+	 * @throws \LogicException if one of parameters is NAN
+	 */
+	public static function areEqual(float $a, float $b): bool
+	{
+		return self::compare($a, $b) === 0;
+	}
+
+
+	/**
+	 * Returns true if $a < $b
+	 * @throws \LogicException if one of parameters is NAN
+	 */
+	public static function isLessThan(float $a, float $b): bool
+	{
+		return self::compare($a, $b) < 0;
+	}
+
+
+	/**
+	 * Returns true if $a <= $b
+	 * @throws \LogicException if one of parameters is NAN
+	 */
+	public static function isLessThanOrEqualTo(float $a, float $b): bool
+	{
+		return self::compare($a, $b) <= 0;
+	}
+
+
+	/**
+	 * Returns true if $a > $b
+	 * @throws \LogicException if one of parameters is NAN
+	 */
+	public static function isGreaterThan(float $a, float $b): bool
+	{
+		return self::compare($a, $b) > 0;
+	}
+
+
+	/**
+	 * Returns true if $a >= $b
+	 * @throws \LogicException if one of parameters is NAN
+	 */
+	public static function isGreaterThanOrEqualTo(float $a, float $b): bool
+	{
+		return self::compare($a, $b) >= 0;
+	}
+}

package/vendor/nette/utils/src/Utils/Helpers.php

@@ -0,0 +1,104 @@
+<?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\Utils;
+
+use Nette;
+
+
+class Helpers
+{
+	/**
+	 * Executes a callback and returns the captured output as a string.
+	 */
+	public static function capture(callable $func): string
+	{
+		ob_start(function () {});
+		try {
+			$func();
+			return ob_get_clean();
+		} catch (\Throwable $e) {
+			ob_end_clean();
+			throw $e;
+		}
+	}
+
+
+	/**
+	 * Returns the last occurred PHP error or an empty string if no error occurred. Unlike error_get_last(),
+	 * it is nit affected by the PHP directive html_errors and always returns text, not HTML.
+	 */
+	public static function getLastError(): string
+	{
+		$message = error_get_last()['message'] ?? '';
+		$message = ini_get('html_errors') ? Html::htmlToText($message) : $message;
+		$message = preg_replace('#^\w+\(.*?\): #', '', $message);
+		return $message;
+	}
+
+
+	/**
+	 * Converts false to null, does not change other values.
+	 */
+	public static function falseToNull(mixed $value): mixed
+	{
+		return $value === false ? null : $value;
+	}
+
+
+	/**
+	 * Returns value clamped to the inclusive range of min and max.
+	 */
+	public static function clamp(int|float $value, int|float $min, int|float $max): int|float
+	{
+		if ($min > $max) {
+			throw new Nette\InvalidArgumentException("Minimum ($min) is not less than maximum ($max).");
+		}
+
+		return min(max($value, $min), $max);
+	}
+
+
+	/**
+	 * Looks for a string from possibilities that is most similar to value, but not the same (for 8-bit encoding).
+	 * @param  string[]  $possibilities
+	 */
+	public static function getSuggestion(array $possibilities, string $value): ?string
+	{
+		$best = null;
+		$min = (strlen($value) / 4 + 1) * 10 + .1;
+		foreach (array_unique($possibilities) as $item) {
+			if ($item !== $value && ($len = levenshtein($item, $value, 10, 11, 10)) < $min) {
+				$min = $len;
+				$best = $item;
+			}
+		}
+
+		return $best;
+	}
+
+
+	/**
+	 * Compares two values in the same way that PHP does. Recognizes operators: >, >=, <, <=, =, ==, ===, !=, !==, <>
+	 */
+	public static function compare(mixed $left, string $operator, mixed $right): bool
+	{
+		return match ($operator) {
+			'>' => $left > $right,
+			'>=' => $left >= $right,
+			'<' => $left < $right,
+			'<=' => $left <= $right,
+			'=', '==' => $left == $right,
+			'===' => $left === $right,
+			'!=', '<>' => $left != $right,
+			'!==' => $left !== $right,
+			default => throw new Nette\InvalidArgumentException("Unknown operator '$operator'"),
+		};
+	}
+}