@vituum/vite-plugin-latte 1.1.0 → 1.2.1

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

@@ -0,0 +1,267 @@
+<?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;
+
+
+/**
+ * PHP type reflection.
+ */
+final class Type
+{
+	/** @var array<int, string|self> */
+	private array $types;
+	private bool $simple;
+	private string $kind; // | &
+
+
+	/**
+	 * Creates a Type object based on reflection. Resolves self, static and parent to the actual class name.
+	 * If the subject has no type, it returns null.
+	 */
+	public static function fromReflection(
+		\ReflectionFunctionAbstract|\ReflectionParameter|\ReflectionProperty $reflection,
+	): ?self
+	{
+		$type = $reflection instanceof \ReflectionFunctionAbstract
+			? $reflection->getReturnType() ?? (PHP_VERSION_ID >= 80100 && $reflection instanceof \ReflectionMethod ? $reflection->getTentativeReturnType() : null)
+			: $reflection->getType();
+
+		return $type ? self::fromReflectionType($type, $reflection, asObject: true) : null;
+	}
+
+
+	private static function fromReflectionType(\ReflectionType $type, $of, bool $asObject): self|string
+	{
+		if ($type instanceof \ReflectionNamedType) {
+			$name = self::resolve($type->getName(), $of);
+			return $asObject
+				? new self($type->allowsNull() && $name !== 'mixed' ? [$name, 'null'] : [$name])
+				: $name;
+
+		} elseif ($type instanceof \ReflectionUnionType || $type instanceof \ReflectionIntersectionType) {
+			return new self(
+				array_map(fn($t) => self::fromReflectionType($t, $of, asObject: false), $type->getTypes()),
+				$type instanceof \ReflectionUnionType ? '|' : '&',
+			);
+
+		} else {
+			throw new Nette\InvalidStateException('Unexpected type of ' . Reflection::toString($of));
+		}
+	}
+
+
+	/**
+	 * Creates the Type object according to the text notation.
+	 */
+	public static function fromString(string $type): self
+	{
+		if (!Validators::isTypeDeclaration($type)) {
+			throw new Nette\InvalidArgumentException("Invalid type '$type'.");
+		}
+
+		if ($type[0] === '?') {
+			return new self([substr($type, 1), 'null']);
+		}
+
+		$unions = [];
+		foreach (explode('|', $type) as $part) {
+			$part = explode('&', trim($part, '()'));
+			$unions[] = count($part) === 1 ? $part[0] : new self($part, '&');
+		}
+
+		return count($unions) === 1 && $unions[0] instanceof self
+			? $unions[0]
+			: new self($unions);
+	}
+
+
+	/**
+	 * Resolves 'self', 'static' and 'parent' to the actual class name.
+	 */
+	public static function resolve(
+		string $type,
+		\ReflectionFunctionAbstract|\ReflectionParameter|\ReflectionProperty $of,
+	): string
+	{
+		$lower = strtolower($type);
+		if ($of instanceof \ReflectionFunction) {
+			return $type;
+		} elseif ($lower === 'self') {
+			return $of->getDeclaringClass()->name;
+		} elseif ($lower === 'static') {
+			return ($of instanceof ReflectionMethod ? $of->getOriginalClass() : $of->getDeclaringClass())->name;
+		} elseif ($lower === 'parent' && $of->getDeclaringClass()->getParentClass()) {
+			return $of->getDeclaringClass()->getParentClass()->name;
+		} else {
+			return $type;
+		}
+	}
+
+
+	private function __construct(array $types, string $kind = '|')
+	{
+		$o = array_search('null', $types, strict: true);
+		if ($o !== false) { // null as last
+			array_splice($types, $o, 1);
+			$types[] = 'null';
+		}
+
+		$this->types = $types;
+		$this->simple = is_string($types[0]) && ($types[1] ?? 'null') === 'null';
+		$this->kind = count($types) > 1 ? $kind : '';
+	}
+
+
+	public function __toString(): string
+	{
+		$multi = count($this->types) > 1;
+		if ($this->simple) {
+			return ($multi ? '?' : '') . $this->types[0];
+		}
+
+		$res = [];
+		foreach ($this->types as $type) {
+			$res[] = $type instanceof self && $multi ? "($type)" : $type;
+		}
+		return implode($this->kind, $res);
+	}
+
+
+	/**
+	 * Returns the array of subtypes that make up the compound type as strings.
+	 * @return array<int, string|string[]>
+	 */
+	public function getNames(): array
+	{
+		return array_map(fn($t) => $t instanceof self ? $t->getNames() : $t, $this->types);
+	}
+
+
+	/**
+	 * Returns the array of subtypes that make up the compound type as Type objects:
+	 * @return self[]
+	 */
+	public function getTypes(): array
+	{
+		return array_map(fn($t) => $t instanceof self ? $t : new self([$t]), $this->types);
+	}
+
+
+	/**
+	 * Returns the type name for simple types, otherwise null.
+	 */
+	public function getSingleName(): ?string
+	{
+		return $this->simple
+			? $this->types[0]
+			: null;
+	}
+
+
+	/**
+	 * Returns true whether it is a union type.
+	 */
+	public function isUnion(): bool
+	{
+		return $this->kind === '|';
+	}
+
+
+	/**
+	 * Returns true whether it is an intersection type.
+	 */
+	public function isIntersection(): bool
+	{
+		return $this->kind === '&';
+	}
+
+
+	/**
+	 * Returns true whether it is a simple type. Single nullable types are also considered to be simple types.
+	 */
+	public function isSimple(): bool
+	{
+		return $this->simple;
+	}
+
+
+	/** @deprecated use isSimple() */
+	public function isSingle(): bool
+	{
+		return $this->simple;
+	}
+
+
+	/**
+	 * Returns true whether the type is both a simple and a PHP built-in type.
+	 */
+	public function isBuiltin(): bool
+	{
+		return $this->simple && Validators::isBuiltinType($this->types[0]);
+	}
+
+
+	/**
+	 * Returns true whether the type is both a simple and a class name.
+	 */
+	public function isClass(): bool
+	{
+		return $this->simple && !Validators::isBuiltinType($this->types[0]);
+	}
+
+
+	/**
+	 * Determines if type is special class name self/parent/static.
+	 */
+	public function isClassKeyword(): bool
+	{
+		return $this->simple && Validators::isClassKeyword($this->types[0]);
+	}
+
+
+	/**
+	 * Verifies type compatibility. For example, it checks if a value of a certain type could be passed as a parameter.
+	 */
+	public function allows(string $subtype): bool
+	{
+		if ($this->types === ['mixed']) {
+			return true;
+		}
+
+		$subtype = self::fromString($subtype);
+		return $subtype->isUnion()
+			? Arrays::every($subtype->types, fn($t) => $this->allows2($t instanceof self ? $t->types : [$t]))
+			: $this->allows2($subtype->types);
+	}
+
+
+	private function allows2(array $subtypes): bool
+	{
+		return $this->isUnion()
+			? Arrays::some($this->types, fn($t) => $this->allows3($t instanceof self ? $t->types : [$t], $subtypes))
+			: $this->allows3($this->types, $subtypes);
+	}
+
+
+	private function allows3(array $types, array $subtypes): bool
+	{
+		return Arrays::every(
+			$types,
+			fn($type) => Arrays::some(
+				$subtypes,
+				fn($subtype) => Validators::isBuiltinType($type)
+					? strcasecmp($type, $subtype) === 0
+					: is_a($subtype, $type, allow_string: true)
+			)
+		);
+	}
+}

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

@@ -0,0 +1,416 @@
+<?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;
+
+
+/**
+ * Validation utilities.
+ */
+class Validators
+{
+	use Nette\StaticClass;
+
+	private const BuiltinTypes = [
+		'string' => 1, 'int' => 1, 'float' => 1, 'bool' => 1, 'array' => 1, 'object' => 1,
+		'callable' => 1, 'iterable' => 1, 'void' => 1, 'null' => 1, 'mixed' => 1, 'false' => 1,
+		'never' => 1, 'true' => 1,
+	];
+
+	/** @var array<string,?callable> */
+	protected static $validators = [
+		// PHP types
+		'array' => 'is_array',
+		'bool' => 'is_bool',
+		'boolean' => 'is_bool',
+		'float' => 'is_float',
+		'int' => 'is_int',
+		'integer' => 'is_int',
+		'null' => 'is_null',
+		'object' => 'is_object',
+		'resource' => 'is_resource',
+		'scalar' => 'is_scalar',
+		'string' => 'is_string',
+
+		// pseudo-types
+		'callable' => [self::class, 'isCallable'],
+		'iterable' => 'is_iterable',
+		'list' => [Arrays::class, 'isList'],
+		'mixed' => [self::class, 'isMixed'],
+		'none' => [self::class, 'isNone'],
+		'number' => [self::class, 'isNumber'],
+		'numeric' => [self::class, 'isNumeric'],
+		'numericint' => [self::class, 'isNumericInt'],
+
+		// string patterns
+		'alnum' => 'ctype_alnum',
+		'alpha' => 'ctype_alpha',
+		'digit' => 'ctype_digit',
+		'lower' => 'ctype_lower',
+		'pattern' => null,
+		'space' => 'ctype_space',
+		'unicode' => [self::class, 'isUnicode'],
+		'upper' => 'ctype_upper',
+		'xdigit' => 'ctype_xdigit',
+
+		// syntax validation
+		'email' => [self::class, 'isEmail'],
+		'identifier' => [self::class, 'isPhpIdentifier'],
+		'uri' => [self::class, 'isUri'],
+		'url' => [self::class, 'isUrl'],
+
+		// environment validation
+		'class' => 'class_exists',
+		'interface' => 'interface_exists',
+		'directory' => 'is_dir',
+		'file' => 'is_file',
+		'type' => [self::class, 'isType'],
+	];
+
+	/** @var array<string,callable> */
+	protected static $counters = [
+		'string' => 'strlen',
+		'unicode' => [Strings::class, 'length'],
+		'array' => 'count',
+		'list' => 'count',
+		'alnum' => 'strlen',
+		'alpha' => 'strlen',
+		'digit' => 'strlen',
+		'lower' => 'strlen',
+		'space' => 'strlen',
+		'upper' => 'strlen',
+		'xdigit' => 'strlen',
+	];
+
+
+	/**
+	 * Verifies that the value is of expected types separated by pipe.
+	 * @throws AssertionException
+	 */
+	public static function assert(mixed $value, string $expected, string $label = 'variable'): void
+	{
+		if (!static::is($value, $expected)) {
+			$expected = str_replace(['|', ':'], [' or ', ' in range '], $expected);
+			$translate = ['boolean' => 'bool', 'integer' => 'int', 'double' => 'float', 'NULL' => 'null'];
+			$type = $translate[gettype($value)] ?? gettype($value);
+			if (is_int($value) || is_float($value) || (is_string($value) && strlen($value) < 40)) {
+				$type .= ' ' . var_export($value, return: true);
+			} elseif (is_object($value)) {
+				$type .= ' ' . $value::class;
+			}
+
+			throw new AssertionException("The $label expects to be $expected, $type given.");
+		}
+	}
+
+
+	/**
+	 * Verifies that element $key in array is of expected types separated by pipe.
+	 * @param  mixed[]  $array
+	 * @throws AssertionException
+	 */
+	public static function assertField(
+		array $array,
+		$key,
+		?string $expected = null,
+		string $label = "item '%' in array",
+	): void
+	{
+		if (!array_key_exists($key, $array)) {
+			throw new AssertionException('Missing ' . str_replace('%', $key, $label) . '.');
+
+		} elseif ($expected) {
+			static::assert($array[$key], $expected, str_replace('%', $key, $label));
+		}
+	}
+
+
+	/**
+	 * Verifies that the value is of expected types separated by pipe.
+	 */
+	public static function is(mixed $value, string $expected): bool
+	{
+		foreach (explode('|', $expected) as $item) {
+			if (str_ends_with($item, '[]')) {
+				if (is_iterable($value) && self::everyIs($value, substr($item, 0, -2))) {
+					return true;
+				}
+
+				continue;
+			} elseif (str_starts_with($item, '?')) {
+				$item = substr($item, 1);
+				if ($value === null) {
+					return true;
+				}
+			}
+
+			[$type] = $item = explode(':', $item, 2);
+			if (isset(static::$validators[$type])) {
+				try {
+					if (!static::$validators[$type]($value)) {
+						continue;
+					}
+				} catch (\TypeError $e) {
+					continue;
+				}
+			} elseif ($type === 'pattern') {
+				if (Strings::match($value, '|^' . ($item[1] ?? '') . '$|D')) {
+					return true;
+				}
+
+				continue;
+			} elseif (!$value instanceof $type) {
+				continue;
+			}
+
+			if (isset($item[1])) {
+				$length = $value;
+				if (isset(static::$counters[$type])) {
+					$length = static::$counters[$type]($value);
+				}
+
+				$range = explode('..', $item[1]);
+				if (!isset($range[1])) {
+					$range[1] = $range[0];
+				}
+
+				if (($range[0] !== '' && $length < $range[0]) || ($range[1] !== '' && $length > $range[1])) {
+					continue;
+				}
+			}
+
+			return true;
+		}
+
+		return false;
+	}
+
+
+	/**
+	 * Finds whether all values are of expected types separated by pipe.
+	 * @param  mixed[]  $values
+	 */
+	public static function everyIs(iterable $values, string $expected): bool
+	{
+		foreach ($values as $value) {
+			if (!static::is($value, $expected)) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+
+	/**
+	 * Checks if the value is an integer or a float.
+	 * @return ($value is int|float ? true : false)
+	 */
+	public static function isNumber(mixed $value): bool
+	{
+		return is_int($value) || is_float($value);
+	}
+
+
+	/**
+	 * Checks if the value is an integer or a integer written in a string.
+	 * @return ($value is non-empty-string ? bool : ($value is int ? true : false))
+	 */
+	public static function isNumericInt(mixed $value): bool
+	{
+		return is_int($value) || (is_string($value) && preg_match('#^[+-]?[0-9]+$#D', $value));
+	}
+
+
+	/**
+	 * Checks if the value is a number or a number written in a string.
+	 * @return ($value is non-empty-string ? bool : ($value is int|float ? true : false))
+	 */
+	public static function isNumeric(mixed $value): bool
+	{
+		return is_float($value) || is_int($value) || (is_string($value) && preg_match('#^[+-]?([0-9]++\.?[0-9]*|\.[0-9]+)$#D', $value));
+	}
+
+
+	/**
+	 * Checks if the value is a syntactically correct callback.
+	 */
+	public static function isCallable(mixed $value): bool
+	{
+		return $value && is_callable($value, syntax_only: true);
+	}
+
+
+	/**
+	 * Checks if the value is a valid UTF-8 string.
+	 */
+	public static function isUnicode(mixed $value): bool
+	{
+		return is_string($value) && preg_match('##u', $value);
+	}
+
+
+	/**
+	 * Checks if the value is 0, '', false or null.
+	 * @return ($value is 0|''|false|null ? true : false)
+	 */
+	public static function isNone(mixed $value): bool
+	{
+		return $value == null; // intentionally ==
+	}
+
+
+	/** @internal */
+	public static function isMixed(): bool
+	{
+		return true;
+	}
+
+
+	/**
+	 * Checks if a variable is a zero-based integer indexed array.
+	 * @deprecated  use Nette\Utils\Arrays::isList
+	 * @return ($value is list ? true : false)
+	 */
+	public static function isList(mixed $value): bool
+	{
+		return Arrays::isList($value);
+	}
+
+
+	/**
+	 * Checks if the value is in the given range [min, max], where the upper or lower limit can be omitted (null).
+	 * Numbers, strings and DateTime objects can be compared.
+	 */
+	public static function isInRange(mixed $value, array $range): bool
+	{
+		if ($value === null || !(isset($range[0]) || isset($range[1]))) {
+			return false;
+		}
+
+		$limit = $range[0] ?? $range[1];
+		if (is_string($limit)) {
+			$value = (string) $value;
+		} elseif ($limit instanceof \DateTimeInterface) {
+			if (!$value instanceof \DateTimeInterface) {
+				return false;
+			}
+		} elseif (is_numeric($value)) {
+			$value *= 1;
+		} else {
+			return false;
+		}
+
+		return (!isset($range[0]) || ($value >= $range[0])) && (!isset($range[1]) || ($value <= $range[1]));
+	}
+
+
+	/**
+	 * Checks if the value is a valid email address. It does not verify that the domain actually exists, only the syntax is verified.
+	 */
+	public static function isEmail(string $value): bool
+	{
+		$atom = "[-a-z0-9!#$%&'*+/=?^_`{|}~]"; // RFC 5322 unquoted characters in local-part
+		$alpha = "a-z\x80-\xFF"; // superset of IDN
+		return (bool) preg_match(<<<XX
+			(^(?n)
+				("([ !#-[\\]-~]*|\\\\[ -~])+"|$atom+(\\.$atom+)*)  # quoted or unquoted
+				@
+				([0-9$alpha]([-0-9$alpha]{0,61}[0-9$alpha])?\\.)+  # domain - RFC 1034
+				[$alpha]([-0-9$alpha]{0,17}[$alpha])?              # top domain
+			$)Dix
+			XX, $value);
+	}
+
+
+	/**
+	 * Checks if the value is a valid URL address.
+	 */
+	public static function isUrl(string $value): bool
+	{
+		$alpha = "a-z\x80-\xFF";
+		return (bool) preg_match(<<<XX
+			(^(?n)
+				https?://(
+					(([-_0-9$alpha]+\\.)*                       # subdomain
+						[0-9$alpha]([-0-9$alpha]{0,61}[0-9$alpha])?\\.)?  # domain
+						[$alpha]([-0-9$alpha]{0,17}[$alpha])?   # top domain
+					|\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}  # IPv4
+					|\\[[0-9a-f:]{3,39}\\]                      # IPv6
+				)(:\\d{1,5})?                                   # port
+				(/\\S*)?                                        # path
+				(\\?\\S*)?                                      # query
+				(\\#\\S*)?                                      # fragment
+			$)Dix
+			XX, $value);
+	}
+
+
+	/**
+	 * Checks if the value is a valid URI address, that is, actually a string beginning with a syntactically valid schema.
+	 */
+	public static function isUri(string $value): bool
+	{
+		return (bool) preg_match('#^[a-z\d+\.-]+:\S+$#Di', $value);
+	}
+
+
+	/**
+	 * Checks whether the input is a class, interface or trait.
+	 * @deprecated
+	 */
+	public static function isType(string $type): bool
+	{
+		return class_exists($type) || interface_exists($type) || trait_exists($type);
+	}
+
+
+	/**
+	 * Checks whether the input is a valid PHP identifier.
+	 */
+	public static function isPhpIdentifier(string $value): bool
+	{
+		return preg_match('#^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$#D', $value) === 1;
+	}
+
+
+	/**
+	 * Determines if type is PHP built-in type. Otherwise, it is the class name.
+	 */
+	public static function isBuiltinType(string $type): bool
+	{
+		return isset(self::BuiltinTypes[strtolower($type)]);
+	}
+
+
+	/**
+	 * Determines if type is special class name self/parent/static.
+	 */
+	public static function isClassKeyword(string $name): bool
+	{
+		return (bool) preg_match('#^(self|parent|static)$#Di', $name);
+	}
+
+
+	/**
+	 * Checks whether the given type declaration is syntactically valid.
+	 */
+	public static function isTypeDeclaration(string $type): bool
+	{
+		return (bool) preg_match(<<<'XX'
+			~((?n)
+				\?? (?<type> \\? (?<name> [a-zA-Z_\x7f-\xff][\w\x7f-\xff]*) (\\ (?&name))* ) |
+				(?<intersection> (?&type) (& (?&type))+ ) |
+				(?<upart> (?&type) | \( (?&intersection) \) )  (\| (?&upart))+
+			)$~xAD
+			XX, $type);
+	}
+}