create-prisma-php-app 1.0.0 → 1.0.1

package/vendor/ramsey/uuid/src/Lazy/LazyUuidFromString.php

@@ -1,226 +0,0 @@
-<?php
-
-/**
- * This file is part of the ramsey/uuid library
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- *
- * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
- * @license http://opensource.org/licenses/MIT MIT
- */
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Lazy;
-
-use DateTimeInterface;
-use Ramsey\Uuid\Exception\UnsupportedOperationException;
-use Ramsey\Uuid\Fields\FieldsInterface;
-use Ramsey\Uuid\Rfc4122\UuidV1;
-use Ramsey\Uuid\Rfc4122\UuidV6;
-use Ramsey\Uuid\TimeBasedUuidInterface;
-use Ramsey\Uuid\Type\Hexadecimal;
-use Ramsey\Uuid\Type\Integer as IntegerObject;
-use Ramsey\Uuid\UuidFactory;
-use Ramsey\Uuid\UuidInterface;
-use ValueError;
-
-use function assert;
-use function bin2hex;
-use function hex2bin;
-use function sprintf;
-use function str_replace;
-use function substr;
-
-/**
- * Lazy version of a UUID: its format has not been determined yet, so it is mostly only usable for string/bytes
- * conversion. This object optimizes instantiation, serialization and string conversion time, at the cost of
- * increased overhead for more advanced UUID operations.
- *
- * @internal this type is used internally for performance reasons, and is not supposed to be directly referenced
- *           in consumer libraries.
- *
- * @psalm-immutable
- *
- * Note: the {@see FieldsInterface} does not declare methods that deprecated API
- *        relies upon: the API has been ported from the {@see \Ramsey\Uuid\Uuid} definition,
- *        and is deprecated anyway.
- * Note: the deprecated API from {@see \Ramsey\Uuid\Uuid} is in use here (on purpose): it will be removed
- *       once the deprecated API is gone from this class too.
- *
- * @psalm-suppress UndefinedInterfaceMethod
- * @psalm-suppress DeprecatedMethod
- */
-final class LazyUuidFromString implements TimeBasedUuidInterface
-{
-    public const VALID_REGEX = '/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/ms';
-
-    private ?UuidInterface $unwrapped = null;
-
-    /**
-     * @psalm-param non-empty-string $uuid
-     */
-    public function __construct(private readonly string $uuid)
-    {
-    }
-
-    /**
-     * @psalm-pure
-     */
-    public static function fromBytes(string $bytes): self
-    {
-        $base16Uuid = bin2hex($bytes);
-
-        return new self(
-            substr($base16Uuid, 0, 8)
-            . '-'
-            . substr($base16Uuid, 8, 4)
-            . '-'
-            . substr($base16Uuid, 12, 4)
-            . '-'
-            . substr($base16Uuid, 16, 4)
-            . '-'
-            . substr($base16Uuid, 20, 12)
-        );
-    }
-
-    /**
-     * @return array{string: non-empty-string}
-     */
-    public function __serialize(): array
-    {
-        return ['string' => $this->uuid];
-    }
-
-    /**
-     * @inheritDoc
-     * @psalm-suppress UnusedMethodCall
-     */
-    public function __unserialize(array $data): void
-    {
-        if (!isset($data['string'])) {
-            throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
-        }
-
-        assert(is_string($data['string']) && $data['string'] !== '');
-
-        $this->uuid = $data['string'];
-    }
-
-    public function getDateTime(): DateTimeInterface
-    {
-        $unwrapped = ($this->unwrapped ?? $this->unwrap());
-
-        if ($unwrapped instanceof TimeBasedUuidInterface) {
-            return $unwrapped->getDateTime();
-        }
-
-        throw new UnsupportedOperationException('Not a time-based UUID');
-    }
-
-    /** @psalm-suppress DeprecatedMethod */
-    public function getUrn(): string
-    {
-        return ($this->unwrapped ?? $this->unwrap())
-            ->getUrn();
-    }
-
-    public function compareTo(UuidInterface $other): int
-    {
-        return ($this->unwrapped ?? $this->unwrap())
-            ->compareTo($other);
-    }
-
-    public function equals(?object $other): bool
-    {
-        if (! $other instanceof UuidInterface) {
-            return false;
-        }
-
-        return $this->uuid === $other->toString();
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @psalm-suppress MoreSpecificReturnType
-     * @psalm-suppress LessSpecificReturnStatement we know that {@see self::$uuid} is a non-empty string, so
-     *                                             we know that {@see hex2bin} will retrieve a non-empty string too.
-     */
-    public function getBytes(): string
-    {
-        /** @phpstan-ignore-next-line PHPStan complains that this is not a non-empty-string. */
-        return (string) hex2bin(str_replace('-', '', $this->uuid));
-    }
-
-    public function getFields(): FieldsInterface
-    {
-        return ($this->unwrapped ?? $this->unwrap())
-            ->getFields();
-    }
-
-    public function getHex(): Hexadecimal
-    {
-        return ($this->unwrapped ?? $this->unwrap())
-            ->getHex();
-    }
-
-    public function getInteger(): IntegerObject
-    {
-        return ($this->unwrapped ?? $this->unwrap())
-            ->getInteger();
-    }
-
-    public function toString(): string
-    {
-        return $this->uuid;
-    }
-
-    public function __toString(): string
-    {
-        return $this->uuid;
-    }
-
-    public function jsonSerialize(): string
-    {
-        return $this->uuid;
-    }
-
-    public function toUuidV1(): UuidV1
-    {
-        $instance = ($this->unwrapped ?? $this->unwrap());
-
-        if ($instance instanceof UuidV1) {
-            return $instance;
-        }
-
-        assert($instance instanceof UuidV6);
-
-        return $instance->toUuidV1();
-    }
-
-    public function toUuidV6(): UuidV6
-    {
-        $instance = ($this->unwrapped ?? $this->unwrap());
-
-        assert($instance instanceof UuidV6);
-
-        return $instance;
-    }
-
-    /**
-     * @psalm-suppress ImpureMethodCall the retrieval of the factory is a clear violation of purity here: this is a
-     *                                  known pitfall of the design of this library, where a value object contains
-     *                                  a mutable reference to a factory. We use a fixed factory here, so the violation
-     *                                  will not have real-world effects, as this object is only instantiated with the
-     *                                  default factory settings/features.
-     * @psalm-suppress InaccessibleProperty property {@see $unwrapped} is used as a cache: we don't expose it to the
-     *                                      outside world, so we should be fine here.
-     */
-    private function unwrap(): UuidInterface
-    {
-        return $this->unwrapped = (new UuidFactory())
-            ->fromString($this->uuid);
-    }
-}

package/vendor/ramsey/uuid/src/Math/BrickMathCalculator.php

@@ -1,145 +0,0 @@
-<?php
-
-/**
- * This file is part of the ramsey/uuid library
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- *
- * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
- * @license http://opensource.org/licenses/MIT MIT
- */
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Math;
-
-use Brick\Math\BigDecimal;
-use Brick\Math\BigInteger;
-use Brick\Math\Exception\MathException;
-use Brick\Math\RoundingMode as BrickMathRounding;
-use Ramsey\Uuid\Exception\InvalidArgumentException;
-use Ramsey\Uuid\Type\Decimal;
-use Ramsey\Uuid\Type\Hexadecimal;
-use Ramsey\Uuid\Type\Integer as IntegerObject;
-use Ramsey\Uuid\Type\NumberInterface;
-
-/**
- * A calculator using the brick/math library for arbitrary-precision arithmetic
- *
- * @psalm-immutable
- */
-final class BrickMathCalculator implements CalculatorInterface
-{
-    private const ROUNDING_MODE_MAP = [
-        RoundingMode::UNNECESSARY => BrickMathRounding::UNNECESSARY,
-        RoundingMode::UP => BrickMathRounding::UP,
-        RoundingMode::DOWN => BrickMathRounding::DOWN,
-        RoundingMode::CEILING => BrickMathRounding::CEILING,
-        RoundingMode::FLOOR => BrickMathRounding::FLOOR,
-        RoundingMode::HALF_UP => BrickMathRounding::HALF_UP,
-        RoundingMode::HALF_DOWN => BrickMathRounding::HALF_DOWN,
-        RoundingMode::HALF_CEILING => BrickMathRounding::HALF_CEILING,
-        RoundingMode::HALF_FLOOR => BrickMathRounding::HALF_FLOOR,
-        RoundingMode::HALF_EVEN => BrickMathRounding::HALF_EVEN,
-    ];
-
-    public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface
-    {
-        $sum = BigInteger::of($augend->toString());
-
-        foreach ($addends as $addend) {
-            $sum = $sum->plus($addend->toString());
-        }
-
-        return new IntegerObject((string) $sum);
-    }
-
-    public function subtract(NumberInterface $minuend, NumberInterface ...$subtrahends): NumberInterface
-    {
-        $difference = BigInteger::of($minuend->toString());
-
-        foreach ($subtrahends as $subtrahend) {
-            $difference = $difference->minus($subtrahend->toString());
-        }
-
-        return new IntegerObject((string) $difference);
-    }
-
-    public function multiply(NumberInterface $multiplicand, NumberInterface ...$multipliers): NumberInterface
-    {
-        $product = BigInteger::of($multiplicand->toString());
-
-        foreach ($multipliers as $multiplier) {
-            $product = $product->multipliedBy($multiplier->toString());
-        }
-
-        return new IntegerObject((string) $product);
-    }
-
-    public function divide(
-        int $roundingMode,
-        int $scale,
-        NumberInterface $dividend,
-        NumberInterface ...$divisors
-    ): NumberInterface {
-        $brickRounding = $this->getBrickRoundingMode($roundingMode);
-
-        $quotient = BigDecimal::of($dividend->toString());
-
-        foreach ($divisors as $divisor) {
-            $quotient = $quotient->dividedBy($divisor->toString(), $scale, $brickRounding);
-        }
-
-        if ($scale === 0) {
-            return new IntegerObject((string) $quotient->toBigInteger());
-        }
-
-        return new Decimal((string) $quotient);
-    }
-
-    public function fromBase(string $value, int $base): IntegerObject
-    {
-        try {
-            return new IntegerObject((string) BigInteger::fromBase($value, $base));
-        } catch (MathException | \InvalidArgumentException $exception) {
-            throw new InvalidArgumentException(
-                $exception->getMessage(),
-                (int) $exception->getCode(),
-                $exception
-            );
-        }
-    }
-
-    public function toBase(IntegerObject $value, int $base): string
-    {
-        try {
-            /** @var non-empty-string */
-            return BigInteger::of($value->toString())->toBase($base);
-        } catch (MathException | \InvalidArgumentException $exception) {
-            throw new InvalidArgumentException(
-                $exception->getMessage(),
-                (int) $exception->getCode(),
-                $exception
-            );
-        }
-    }
-
-    public function toHexadecimal(IntegerObject $value): Hexadecimal
-    {
-        return new Hexadecimal($this->toBase($value, 16));
-    }
-
-    public function toInteger(Hexadecimal $value): IntegerObject
-    {
-        return $this->fromBase($value->toString(), 16);
-    }
-
-    /**
-     * Maps ramsey/uuid rounding modes to those used by brick/math
-     */
-    private function getBrickRoundingMode(int $roundingMode): int
-    {
-        return self::ROUNDING_MODE_MAP[$roundingMode] ?? 0;
-    }
-}

package/vendor/ramsey/uuid/src/Math/CalculatorInterface.php

@@ -1,106 +0,0 @@
-<?php
-
-/**
- * This file is part of the ramsey/uuid library
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- *
- * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
- * @license http://opensource.org/licenses/MIT MIT
- */
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Math;
-
-use Ramsey\Uuid\Type\Hexadecimal;
-use Ramsey\Uuid\Type\Integer as IntegerObject;
-use Ramsey\Uuid\Type\NumberInterface;
-
-/**
- * A calculator performs arithmetic operations on numbers
- *
- * @psalm-immutable
- */
-interface CalculatorInterface
-{
-    /**
-     * Returns the sum of all the provided parameters
-     *
-     * @param NumberInterface $augend The integer being added to
-     * @param NumberInterface ...$addends The additional integers to add to the augend
-     *
-     * @return NumberInterface The sum of all the parameters
-     */
-    public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface;
-
-    /**
-     * Returns the difference of all the provided parameters
-     *
-     * @param NumberInterface $minuend The integer being subtracted from
-     * @param NumberInterface ...$subtrahends The integers to subtract from the minuend
-     *
-     * @return NumberInterface The difference after subtracting all parameters
-     */
-    public function subtract(NumberInterface $minuend, NumberInterface ...$subtrahends): NumberInterface;
-
-    /**
-     * Returns the product of all the provided parameters
-     *
-     * @param NumberInterface $multiplicand The integer to be multiplied
-     * @param NumberInterface ...$multipliers The factors by which to multiply the multiplicand
-     *
-     * @return NumberInterface The product of multiplying all the provided parameters
-     */
-    public function multiply(NumberInterface $multiplicand, NumberInterface ...$multipliers): NumberInterface;
-
-    /**
-     * Returns the quotient of the provided parameters divided left-to-right
-     *
-     * @param int $roundingMode The RoundingMode constant to use for this operation
-     * @param int $scale The scale to use for this operation
-     * @param NumberInterface $dividend The integer to be divided
-     * @param NumberInterface ...$divisors The integers to divide $dividend by, in
-     *     the order in which the division operations should take place
-     *     (left-to-right)
-     *
-     * @return NumberInterface The quotient of dividing the provided parameters left-to-right
-     */
-    public function divide(
-        int $roundingMode,
-        int $scale,
-        NumberInterface $dividend,
-        NumberInterface ...$divisors
-    ): NumberInterface;
-
-    /**
-     * Converts a value from an arbitrary base to a base-10 integer value
-     *
-     * @param non-empty-string $value The value to convert
-     * @param int $base The base to convert from (i.e., 2, 16, 32, etc.)
-     *
-     * @return IntegerObject The base-10 integer value of the converted value
-     */
-    public function fromBase(string $value, int $base): IntegerObject;
-
-    /**
-     * Converts a base-10 integer value to an arbitrary base
-     *
-     * @param IntegerObject $value The integer value to convert
-     * @param int $base The base to convert to (i.e., 2, 16, 32, etc.)
-     *
-     * @return non-empty-string The value represented in the specified base
-     */
-    public function toBase(IntegerObject $value, int $base): string;
-
-    /**
-     * Converts an Integer instance to a Hexadecimal instance
-     */
-    public function toHexadecimal(IntegerObject $value): Hexadecimal;
-
-    /**
-     * Converts a Hexadecimal instance to an Integer instance
-     */
-    public function toInteger(Hexadecimal $value): IntegerObject;
-}

package/vendor/ramsey/uuid/src/Math/RoundingMode.php

@@ -1,146 +0,0 @@
-<?php
-
-/**
- * This file was originally part of brick/math
- *
- * Copyright (c) 2013-present Benjamin Morel
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * @link https://github.com/brick/math brick/math at GitHub
- */
-
-declare(strict_types=1);
-
-namespace Ramsey\Uuid\Math;
-
-/**
- * Specifies a rounding behavior for numerical operations capable of discarding
- * precision.
- *
- * Each rounding mode indicates how the least significant returned digit of a
- * rounded result is to be calculated. If fewer digits are returned than the
- * digits needed to represent the exact numerical result, the discarded digits
- * will be referred to as the discarded fraction regardless the digits'
- * contribution to the value of the number. In other words, considered as a
- * numerical value, the discarded fraction could have an absolute value greater
- * than one.
- */
-final class RoundingMode
-{
-    /**
-     * Private constructor. This class is not instantiable.
-     *
-     * @codeCoverageIgnore
-     */
-    private function __construct()
-    {
-    }
-
-    /**
-     * Asserts that the requested operation has an exact result, hence no
-     * rounding is necessary.
-     */
-    public const UNNECESSARY = 0;
-
-    /**
-     * Rounds away from zero.
-     *
-     * Always increments the digit prior to a nonzero discarded fraction.
-     * Note that this rounding mode never decreases the magnitude of the
-     * calculated value.
-     */
-    public const UP = 1;
-
-    /**
-     * Rounds towards zero.
-     *
-     * Never increments the digit prior to a discarded fraction (i.e.,
-     * truncates). Note that this rounding mode never increases the magnitude of
-     * the calculated value.
-     */
-    public const DOWN = 2;
-
-    /**
-     * Rounds towards positive infinity.
-     *
-     * If the result is positive, behaves as for UP; if negative, behaves as for
-     * DOWN. Note that this rounding mode never decreases the calculated value.
-     */
-    public const CEILING = 3;
-
-    /**
-     * Rounds towards negative infinity.
-     *
-     * If the result is positive, behave as for DOWN; if negative, behave as for
-     * UP. Note that this rounding mode never increases the calculated value.
-     */
-    public const FLOOR = 4;
-
-    /**
-     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
-     * in which case round up.
-     *
-     * Behaves as for UP if the discarded fraction is >= 0.5; otherwise, behaves
-     * as for DOWN. Note that this is the rounding mode commonly taught at
-     * school.
-     */
-    public const HALF_UP = 5;
-
-    /**
-     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
-     * in which case round down.
-     *
-     * Behaves as for UP if the discarded fraction is > 0.5; otherwise, behaves
-     * as for DOWN.
-     */
-    public const HALF_DOWN = 6;
-
-    /**
-     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
-     * in which case round towards positive infinity.
-     *
-     * If the result is positive, behaves as for HALF_UP; if negative, behaves
-     * as for HALF_DOWN.
-     */
-    public const HALF_CEILING = 7;
-
-    /**
-     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
-     * in which case round towards negative infinity.
-     *
-     * If the result is positive, behaves as for HALF_DOWN; if negative, behaves
-     * as for HALF_UP.
-     */
-    public const HALF_FLOOR = 8;
-
-    /**
-     * Rounds towards the "nearest neighbor" unless both neighbors are
-     * equidistant, in which case rounds towards the even neighbor.
-     *
-     * Behaves as for HALF_UP if the digit to the left of the discarded fraction
-     * is odd; behaves as for HALF_DOWN if it's even.
-     *
-     * Note that this is the rounding mode that statistically minimizes
-     * cumulative error when applied repeatedly over a sequence of calculations.
-     * It is sometimes known as "Banker's rounding", and is chiefly used in the
-     * USA.
-     */
-    public const HALF_EVEN = 9;
-}