create-berna-stencil 1.0.24 → 1.0.25

package/src/api/core/vendor/fakerphp/faker/src/Faker/Calculator/Isbn.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Faker\Calculator;
+
+/**
+ * Utility class for validating ISBN-10
+ */
+class Isbn
+{
+    /**
+     * @var string ISBN-10 validation pattern
+     */
+    public const PATTERN = '/^\d{9}[0-9X]$/';
+
+    /**
+     * ISBN-10 check digit
+     *
+     * @see http://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digits
+     *
+     * @param string $input ISBN without check-digit
+     *
+     * @throws \LengthException When wrong input length passed
+     */
+    public static function checksum(string $input): string
+    {
+        // We're calculating check digit for ISBN-10
+        // so, the length of the input should be 9
+        $length = 9;
+
+        if (strlen($input) !== $length) {
+            throw new \LengthException(sprintf('Input length should be equal to %d', $length));
+        }
+
+        $digits = str_split($input);
+        array_walk(
+            $digits,
+            static function (&$digit, $position): void {
+                $digit = (10 - $position) * $digit;
+            },
+        );
+        $result = (11 - array_sum($digits) % 11) % 11;
+
+        // 10 is replaced by X
+        return ($result < 10) ? (string) $result : 'X';
+    }
+
+    /**
+     * Checks whether the provided number is a valid ISBN-10 number
+     *
+     * @param string $isbn ISBN to check
+     */
+    public static function isValid(string $isbn): bool
+    {
+        if (!preg_match(self::PATTERN, $isbn)) {
+            return false;
+        }
+
+        return self::checksum(substr($isbn, 0, -1)) === substr($isbn, -1);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Calculator/Luhn.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Faker\Calculator;
+
+/**
+ * Utility class for generating and validating Luhn numbers.
+ *
+ * Luhn algorithm is used to validate credit card numbers, IMEI numbers, and
+ * National Provider Identifier numbers.
+ *
+ * @see http://en.wikipedia.org/wiki/Luhn_algorithm
+ */
+class Luhn
+{
+    /**
+     * @return int
+     */
+    private static function checksum(string $number)
+    {
+        $number = (string) $number;
+        $length = strlen($number);
+        $sum = 0;
+
+        for ($i = $length - 1; $i >= 0; $i -= 2) {
+            $sum += $number[$i];
+        }
+
+        for ($i = $length - 2; $i >= 0; $i -= 2) {
+            $sum += array_sum(str_split($number[$i] * 2));
+        }
+
+        return $sum % 10;
+    }
+
+    /**
+     * @return string
+     */
+    public static function computeCheckDigit(string $partialNumber)
+    {
+        $checkDigit = self::checksum($partialNumber . '0');
+
+        if ($checkDigit === 0) {
+            return '0';
+        }
+
+        return (string) (10 - $checkDigit);
+    }
+
+    /**
+     * Checks whether a number (partial number + check digit) is Luhn compliant
+     *
+     * @return bool
+     */
+    public static function isValid(string $number)
+    {
+        return self::checksum($number) === 0;
+    }
+
+    /**
+     * Generate a Luhn compliant number.
+     *
+     * @return string
+     */
+    public static function generateLuhnNumber(string $partialValue)
+    {
+        if (!preg_match('/^\d+$/', $partialValue)) {
+            throw new \InvalidArgumentException('Argument should be an integer.');
+        }
+
+        return $partialValue . Luhn::computeCheckDigit($partialValue);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Calculator/TCNo.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Faker\Calculator;
+
+/**
+ * @deprecated moved to tr_TR\Person, use {@link \Faker\Provider\tr_TR\Person}.
+ * @see \Faker\Provider\tr_TR\Person
+ */
+class TCNo
+{
+    /**
+     * Generates Turkish Identity Number Checksum
+     * Gets first 9 digit as prefix and calculates checksum
+     *
+     * https://en.wikipedia.org/wiki/Turkish_Identification_Number
+     *
+     * @param string $identityPrefix
+     *
+     * @return string Checksum (two digit)
+     *
+     * @deprecated use {@link \Faker\Provider\tr_TR\Person::tcNoChecksum()} instead
+     * @see \Faker\Provider\tr_TR\Person::tcNoChecksum()
+     */
+    public static function checksum($identityPrefix)
+    {
+        return \Faker\Provider\tr_TR\Person::tcNoChecksum($identityPrefix);
+    }
+
+    /**
+     * Checks whether a TCNo has a valid checksum
+     *
+     * @param string $tcNo
+     *
+     * @return bool
+     *
+     * @deprecated use {@link \Faker\Provider\tr_TR\Person::tcNoIsValid()} instead
+     * @see \Faker\Provider\tr_TR\Person::tcNoIsValid()
+     */
+    public static function isValid($tcNo)
+    {
+        return \Faker\Provider\tr_TR\Person::tcNoIsValid($tcNo);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/ChanceGenerator.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Faker;
+
+use Faker\Extension\Extension;
+
+/**
+ * This generator returns a default value for all called properties
+ * and methods. It works with Faker\Generator::optional().
+ *
+ * @mixin Generator
+ */
+class ChanceGenerator
+{
+    private $generator;
+    private $weight;
+    protected $default;
+
+    /**
+     * @param Extension|Generator $generator
+     */
+    public function __construct($generator, float $weight, $default = null)
+    {
+        $this->default = $default;
+        $this->generator = $generator;
+        $this->weight = $weight;
+    }
+
+    public function ext(string $id)
+    {
+        return new self($this->generator->ext($id), $this->weight, $this->default);
+    }
+
+    /**
+     * Catch and proxy all generator calls but return only valid values
+     *
+     * @param string $attribute
+     *
+     * @deprecated Use a method instead.
+     */
+    public function __get($attribute)
+    {
+        trigger_deprecation('fakerphp/faker', '1.14', 'Accessing property "%s" is deprecated, use "%s()" instead.', $attribute, $attribute);
+
+        return $this->__call($attribute, []);
+    }
+
+    /**
+     * @param string $name
+     * @param array  $arguments
+     */
+    public function __call($name, $arguments)
+    {
+        if (mt_rand(1, 100) <= (100 * $this->weight)) {
+            return call_user_func_array([$this->generator, $name], $arguments);
+        }
+
+        return $this->default;
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Container/Container.php

@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Faker\Container;
+
+use Faker\Extension\Extension;
+
+/**
+ * A simple implementation of a container.
+ *
+ * @experimental This class is experimental and does not fall under our BC promise
+ */
+final class Container implements ContainerInterface
+{
+    /**
+     * @var array<string, callable|object|string>
+     */
+    private array $definitions;
+
+    private array $services = [];
+
+    /**
+     * Create a container object with a set of definitions. The array value MUST
+     * produce an object that implements Extension.
+     *
+     * @param array<string, callable|object|string> $definitions
+     */
+    public function __construct(array $definitions)
+    {
+        $this->definitions = $definitions;
+    }
+
+    /**
+     * Retrieve a definition from the container.
+     *
+     * @param string $id
+     *
+     * @throws \InvalidArgumentException
+     * @throws \RuntimeException
+     * @throws ContainerException
+     * @throws NotInContainerException
+     */
+    public function get($id): Extension
+    {
+        if (!is_string($id)) {
+            throw new \InvalidArgumentException(sprintf(
+                'First argument of %s::get() must be string',
+                self::class,
+            ));
+        }
+
+        if (array_key_exists($id, $this->services)) {
+            return $this->services[$id];
+        }
+
+        if (!$this->has($id)) {
+            throw new NotInContainerException(sprintf(
+                'There is not service with id "%s" in the container.',
+                $id,
+            ));
+        }
+
+        $definition = $this->definitions[$id];
+
+        $service = $this->getService($id, $definition);
+
+        if (!$service instanceof Extension) {
+            throw new \RuntimeException(sprintf(
+                'Service resolved for identifier "%s" does not implement the %s" interface.',
+                $id,
+                Extension::class,
+            ));
+        }
+
+        $this->services[$id] = $service;
+
+        return $service;
+    }
+
+    /**
+     * Get the service from a definition.
+     *
+     * @param callable|object|string $definition
+     */
+    private function getService(string $id, $definition)
+    {
+        if (is_callable($definition)) {
+            try {
+                return $definition();
+            } catch (\Throwable $e) {
+                throw new ContainerException(
+                    sprintf('Error while invoking callable for "%s"', $id),
+                    0,
+                    $e,
+                );
+            }
+        } elseif (is_object($definition)) {
+            return $definition;
+        } elseif (is_string($definition)) {
+            if (class_exists($definition)) {
+                try {
+                    return new $definition();
+                } catch (\Throwable $e) {
+                    throw new ContainerException(sprintf('Could not instantiate class "%s"', $id), 0, $e);
+                }
+            }
+
+            throw new ContainerException(sprintf(
+                'Could not instantiate class "%s". Class was not found.',
+                $id,
+            ));
+        } else {
+            throw new ContainerException(sprintf(
+                'Invalid type for definition with id "%s"',
+                $id,
+            ));
+        }
+    }
+
+    /**
+     * Check if the container contains a given identifier.
+     *
+     * @param string $id
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function has($id): bool
+    {
+        if (!is_string($id)) {
+            throw new \InvalidArgumentException(sprintf(
+                'First argument of %s::get() must be string',
+                self::class,
+            ));
+        }
+
+        return array_key_exists($id, $this->definitions);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Container/ContainerBuilder.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Faker\Container;
+
+use Faker\Core;
+use Faker\Extension;
+
+/**
+ * @experimental This class is experimental and does not fall under our BC promise
+ */
+final class ContainerBuilder
+{
+    /**
+     * @var array<string, callable|object|string>
+     */
+    private array $definitions = [];
+
+    /**
+     * @param callable|object|string $definition
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function add(string $id, $definition): self
+    {
+        if (!is_string($definition) && !is_callable($definition) && !is_object($definition)) {
+            throw new \InvalidArgumentException(sprintf(
+                'First argument to "%s::add()" must be a string, callable or object.',
+                self::class,
+            ));
+        }
+
+        $this->definitions[$id] = $definition;
+
+        return $this;
+    }
+
+    public function build(): ContainerInterface
+    {
+        return new Container($this->definitions);
+    }
+
+    private static function defaultExtensions(): array
+    {
+        return [
+            Extension\BarcodeExtension::class => Core\Barcode::class,
+            Extension\BloodExtension::class => Core\Blood::class,
+            Extension\ColorExtension::class => Core\Color::class,
+            Extension\DateTimeExtension::class => Core\DateTime::class,
+            Extension\FileExtension::class => Core\File::class,
+            Extension\NumberExtension::class => Core\Number::class,
+            Extension\UuidExtension::class => Core\Uuid::class,
+            Extension\VersionExtension::class => Core\Version::class,
+        ];
+    }
+
+    public static function withDefaultExtensions(): self
+    {
+        $instance = new self();
+
+        foreach (self::defaultExtensions() as $id => $definition) {
+            $instance->add($id, $definition);
+        }
+
+        return $instance;
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Container/ContainerException.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Faker\Container;
+
+use Psr\Container\ContainerExceptionInterface;
+
+/**
+ * @experimental This class is experimental and does not fall under our BC promise
+ */
+final class ContainerException extends \RuntimeException implements ContainerExceptionInterface
+{
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Container/ContainerInterface.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Faker\Container;
+
+use Psr\Container\ContainerInterface as BaseContainerInterface;
+
+interface ContainerInterface extends BaseContainerInterface
+{
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Container/NotInContainerException.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Faker\Container;
+
+use Psr\Container\NotFoundExceptionInterface;
+
+/**
+ * @experimental This class is experimental and does not fall under our BC promise
+ */
+final class NotInContainerException extends \RuntimeException implements NotFoundExceptionInterface
+{
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Core/Barcode.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Faker\Core;
+
+use Faker\Calculator;
+use Faker\Extension;
+
+/**
+ * @experimental This class is experimental and does not fall under our BC promise
+ */
+final class Barcode implements Extension\BarcodeExtension
+{
+    private Extension\NumberExtension $numberExtension;
+
+    public function __construct(?Extension\NumberExtension $numberExtension = null)
+    {
+        $this->numberExtension = $numberExtension ?: new Number();
+    }
+
+    private function ean(int $length = 13): string
+    {
+        $code = Extension\Helper::numerify(str_repeat('#', $length - 1));
+
+        return sprintf('%s%s', $code, Calculator\Ean::checksum($code));
+    }
+
+    public function ean13(): string
+    {
+        return $this->ean();
+    }
+
+    public function ean8(): string
+    {
+        return $this->ean(8);
+    }
+
+    public function isbn10(): string
+    {
+        $code = Extension\Helper::numerify(str_repeat('#', 9));
+
+        return sprintf('%s%s', $code, Calculator\Isbn::checksum($code));
+    }
+
+    public function isbn13(): string
+    {
+        $code = '97' . $this->numberExtension->numberBetween(8, 9) . Extension\Helper::numerify(str_repeat('#', 9));
+
+        return sprintf('%s%s', $code, Calculator\Ean::checksum($code));
+    }
+}

package/src/api/core/vendor/fakerphp/faker/src/Faker/Core/Blood.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Faker\Core;
+
+use Faker\Extension;
+
+/**
+ * @experimental This class is experimental and does not fall under our BC promise
+ */
+final class Blood implements Extension\BloodExtension
+{
+    /**
+     * @var string[]
+     */
+    private array $bloodTypes = ['A', 'AB', 'B', 'O'];
+
+    /**
+     * @var string[]
+     */
+    private array $bloodRhFactors = ['+', '-'];
+
+    public function bloodType(): string
+    {
+        return Extension\Helper::randomElement($this->bloodTypes);
+    }
+
+    public function bloodRh(): string
+    {
+        return Extension\Helper::randomElement($this->bloodRhFactors);
+    }
+
+    public function bloodGroup(): string
+    {
+        return sprintf(
+            '%s%s',
+            $this->bloodType(),
+            $this->bloodRh(),
+        );
+    }
+}