1

app/JsonRpc/CollectorService.php

@@ -0,0 +1,106 @@
+<?php
+namespace App\JsonRpc;
+
+use App\Model\OldModel\Article as OldArticle;
+use App\Model\Article;
+use App\Model\Web;
+use Hyperf\DbConnection\Db;
+use Hyperf\RpcServer\Annotation\RpcService;
+use App\Tools\Result;
+
+
+#[RpcService(name: "CollectorService", protocol: "jsonrpc-http", server: "jsonrpc-http")]
+class CollectorService implements CollectorServiceInterface
+{
+    /**
+     * 添加网站
+     * @param array $data
+     * @return array|mixed
+     */
+    public function addWeb(array $data): array
+    {
+        $where = [
+            'name' => $data['name']
+        ];
+        $isweb = Web::where($where)->first();
+        if(empty($isweb)){
+            date_default_timezone_set('Asia/Shanghai');
+            $time = time();
+            $catetime = date('Y-m-d H:i:s', $time);
+            $data['created_at'] = $catetime;
+            $web = Web::insert($data);
+            
+        }else{
+            return Result::error('此网站已存在，不可重复添加！');
+        }
+        if(empty($web)){
+            return Result::error('添加失败');
+        }
+        return Result::success('添加成功');
+    }
+    /**
+     * 获取并搜索网站
+     * @param array $data
+     * @return array|mixed
+     */
+    public function getWeb(array $data): array
+    {
+        
+        if(isset($data['keyWord'])){
+            $where = [
+                ['name','like','%'.$data['keyWord'].'%']
+            ];
+            $webss = Web::where($where)->first();
+            if(empty($webss)){
+                return Result::error('未查找到相关网站！');
+            }
+        }else{
+            $web = Web::get();
+        }
+        
+        if(empty($web)){
+            return Result::error('您还未添加网站，请先去添加！');
+            
+        }
+        
+        return Result::success($web);
+    }
+    /**
+     * 修改网站
+     * @param array $data
+     * @return array|mixed
+     */
+    public function upWeb(array $data): array
+    {
+        $web = Web::where('id',$data['id'])->first();
+        if(empty($web)){
+            return Result::error('请输入正确的网站id！');
+            
+        }else{
+            $id = Web::where('id',$data['id'])->update($data);
+            if(empty($id)){
+                return Result::error('无法修改！');
+            }
+        }
+        return Result::success($id);
+    }
+    /**
+     * 删除网站
+     * @param array $data
+     * @return array|mixed
+     */
+    public function delWeb(array $data): array
+    {
+        $web = Web::where('id',$data['id'])->first();
+        if(empty($web)){
+            return Result::error('请输入正确的网站id！');
+            
+        }else{
+            $id = Web::where('id',$data['id'])->delete();
+            if(empty($id)){
+                return Result::error('无法删除！');
+            }
+        }
+        return Result::success($id);
+    }
+}

app/JsonRpc/CollectorServiceInterface.php

@@ -0,0 +1,29 @@
+<?php
+namespace App\JsonRpc;
+interface CollectorServiceInterface
+{
+    
+    /**
+     * @param array $data
+     *  @return array
+    */
+    public function addWeb(array $data):array;
+    /**
+     * @param array $data
+     *  @return array
+    */
+    public function getWeb(array $data):array;
+     /**
+     * @param array $data
+     *  @return array
+    */
+    public function upWeb(array $data):array;
+    /**
+     * @param array $data
+     *  @return array
+    */
+    public function delWeb(array $data):array;
+
+}
+
+

app/Model/OldModel/Article.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Model\OldModel;
+
+use Hyperf\DbConnection\Model\Model;
+
+/**
+ */
+class Article extends Model
+{
+    /**
+     * The table associated with the model.
+     */
+    protected ?string $table = 'article';
+    protected ?string $connection = 'secondary';
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected array $fillable = [];
+
+    /**
+     * The attributes that should be cast to native types.
+     */
+    protected array $casts = [];
+}

app/Model/Web.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Model;
+
+use Hyperf\DbConnection\Model\Model;
+
+/**
+ */
+class Web extends Model
+{
+    /**
+     * The table associated with the model.
+     */
+    protected ?string $table = 'web';
+
+    /**
+     * The attributes that are mass assignable.
+     */
+    protected array $fillable = [];
+
+    /**
+     * The attributes that should be cast to native types.
+     */
+    protected array $casts = [];
+}

runtime/container/proxy/App_Controller_AbstractController.proxy.php

@@ -0,0 +1,32 @@
+<?php
+
+declare (strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+namespace App\Controller;
+
+use Hyperf\Di\Annotation\Inject;
+use Hyperf\HttpServer\Contract\RequestInterface;
+use Hyperf\HttpServer\Contract\ResponseInterface;
+use Psr\Container\ContainerInterface;
+abstract class AbstractController
+{
+    use \Hyperf\Di\Aop\ProxyTrait;
+    use \Hyperf\Di\Aop\PropertyHandlerTrait;
+    function __construct()
+    {
+        $this->__handlePropertyHandler(__CLASS__);
+    }
+    #[Inject]
+    protected ContainerInterface $container;
+    #[Inject]
+    protected RequestInterface $request;
+    #[Inject]
+    protected ResponseInterface $response;
+}

runtime/container/proxy/App_Controller_IndexController.proxy.php

@@ -0,0 +1,31 @@
+<?php
+
+declare (strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+namespace App\Controller;
+
+class IndexController extends AbstractController
+{
+    use \Hyperf\Di\Aop\ProxyTrait;
+    use \Hyperf\Di\Aop\PropertyHandlerTrait;
+    function __construct()
+    {
+        if (method_exists(parent::class, '__construct')) {
+            parent::__construct(...func_get_args());
+        }
+        $this->__handlePropertyHandler(__CLASS__);
+    }
+    public function index()
+    {
+        $user = $this->request->input('user', 'Hyperf');
+        $method = $this->request->getMethod();
+        return ['method' => $method, 'message' => "Hello {$user}."];
+    }
+}

vendor/composer/pcre/extension.neon

@@ -0,0 +1,22 @@
+# composer/pcre PHPStan extensions
+#
+# These can be reused by third party packages by including 'vendor/composer/pcre/extension.neon'
+# in your phpstan config
+
+services:
+    -
+        class: Composer\Pcre\PHPStan\PregMatchParameterOutTypeExtension
+        tags:
+            - phpstan.staticMethodParameterOutTypeExtension
+    -
+        class: Composer\Pcre\PHPStan\PregMatchTypeSpecifyingExtension
+        tags:
+            - phpstan.typeSpecifier.staticMethodTypeSpecifyingExtension
+    -
+        class: Composer\Pcre\PHPStan\PregReplaceCallbackClosureTypeExtension
+        tags:
+            - phpstan.staticMethodParameterClosureTypeExtension
+
+rules:
+    - Composer\Pcre\PHPStan\UnsafeStrictGroupsCallRule
+    - Composer\Pcre\PHPStan\InvalidRegexPatternRule

vendor/composer/pcre/src/PHPStan/InvalidRegexPatternRule.php

@@ -0,0 +1,142 @@
+<?php declare(strict_types = 1);
+
+namespace Composer\Pcre\PHPStan;
+
+use Composer\Pcre\Preg;
+use Composer\Pcre\Regex;
+use Composer\Pcre\PcreException;
+use Nette\Utils\RegexpException;
+use Nette\Utils\Strings;
+use PhpParser\Node;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Name\FullyQualified;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use function in_array;
+use function sprintf;
+
+/**
+ * Copy of PHPStan's RegularExpressionPatternRule
+ *
+ * @implements Rule<StaticCall>
+ */
+class InvalidRegexPatternRule implements Rule
+{
+    public function getNodeType(): string
+    {
+        return StaticCall::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $patterns = $this->extractPatterns($node, $scope);
+
+        $errors = [];
+        foreach ($patterns as $pattern) {
+            $errorMessage = $this->validatePattern($pattern);
+            if ($errorMessage === null) {
+                continue;
+            }
+
+            $errors[] = RuleErrorBuilder::message(sprintf('Regex pattern is invalid: %s', $errorMessage))->identifier('regexp.pattern')->build();
+        }
+
+        return $errors;
+    }
+
+    /**
+     * @return string[]
+     */
+    private function extractPatterns(StaticCall $node, Scope $scope): array
+    {
+        if (!$node->class instanceof FullyQualified) {
+            return [];
+        }
+        $isRegex = $node->class->toString() === Regex::class;
+        $isPreg = $node->class->toString() === Preg::class;
+        if (!$isRegex && !$isPreg) {
+            return [];
+        }
+        if (!$node->name instanceof Node\Identifier || !Preg::isMatch('{^(match|isMatch|grep|replace|split)}', $node->name->name)) {
+            return [];
+        }
+
+        $functionName = $node->name->name;
+        if (!isset($node->getArgs()[0])) {
+            return [];
+        }
+
+        $patternNode = $node->getArgs()[0]->value;
+        $patternType = $scope->getType($patternNode);
+
+        $patternStrings = [];
+
+        foreach ($patternType->getConstantStrings() as $constantStringType) {
+            if ($functionName === 'replaceCallbackArray') {
+                continue;
+            }
+
+            $patternStrings[] = $constantStringType->getValue();
+        }
+
+        foreach ($patternType->getConstantArrays() as $constantArrayType) {
+            if (
+                in_array($functionName, [
+                    'replace',
+                    'replaceCallback',
+                ], true)
+            ) {
+                foreach ($constantArrayType->getValueTypes() as $arrayKeyType) {
+                    foreach ($arrayKeyType->getConstantStrings() as $constantString) {
+                        $patternStrings[] = $constantString->getValue();
+                    }
+                }
+            }
+
+            if ($functionName !== 'replaceCallbackArray') {
+                continue;
+            }
+
+            foreach ($constantArrayType->getKeyTypes() as $arrayKeyType) {
+                foreach ($arrayKeyType->getConstantStrings() as $constantString) {
+                    $patternStrings[] = $constantString->getValue();
+                }
+            }
+        }
+
+        return $patternStrings;
+    }
+
+    private function validatePattern(string $pattern): ?string
+    {
+        try {
+            $msg = null;
+            $prev = set_error_handler(function (int $severity, string $message, string $file) use (&$msg): bool {
+                $msg = preg_replace("#^preg_match(_all)?\\(.*?\\): #", '', $message);
+
+                return true;
+            });
+
+            if ($pattern === '') {
+                return 'Empty string is not a valid regular expression';
+            }
+
+            Preg::match($pattern, '');
+            if ($msg !== null) {
+                return $msg;
+            }
+        } catch (PcreException $e) {
+            if ($e->getCode() === PREG_INTERNAL_ERROR && $msg !== null) {
+                return $msg;
+            }
+
+            return preg_replace('{.*? failed executing ".*": }', '', $e->getMessage());
+        } finally {
+            restore_error_handler();
+        }
+
+        return null;
+    }
+
+}

vendor/composer/pcre/src/PHPStan/PregMatchFlags.php

@@ -0,0 +1,70 @@
+<?php declare(strict_types=1);
+
+namespace Composer\Pcre\PHPStan;
+
+use PHPStan\Analyser\Scope;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\IntersectionType;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\Type;
+use PhpParser\Node\Arg;
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use PHPStan\Type\TypeTraverser;
+use PHPStan\Type\UnionType;
+
+final class PregMatchFlags
+{
+    static public function getType(?Arg $flagsArg, Scope $scope): ?Type
+    {
+        if ($flagsArg === null) {
+            return new ConstantIntegerType(PREG_UNMATCHED_AS_NULL);
+        }
+
+        $flagsType = $scope->getType($flagsArg->value);
+
+        $constantScalars = $flagsType->getConstantScalarValues();
+        if ($constantScalars === []) {
+            return null;
+        }
+
+        $internalFlagsTypes = [];
+        foreach ($flagsType->getConstantScalarValues() as $constantScalarValue) {
+            if (!is_int($constantScalarValue)) {
+                return null;
+            }
+
+            $internalFlagsTypes[] = new ConstantIntegerType($constantScalarValue | PREG_UNMATCHED_AS_NULL);
+        }
+        return TypeCombinator::union(...$internalFlagsTypes);
+    }
+
+    static public function removeNullFromMatches(Type $matchesType): Type
+    {
+        return TypeTraverser::map($matchesType, static function (Type $type, callable $traverse): Type {
+            if ($type instanceof UnionType || $type instanceof IntersectionType) {
+                return $traverse($type);
+            }
+
+            if ($type instanceof ConstantArrayType) {
+                return new ConstantArrayType(
+                    $type->getKeyTypes(),
+                    array_map(static function (Type $valueType) use ($traverse): Type {
+                        return $traverse($valueType);
+                    }, $type->getValueTypes()),
+                    $type->getNextAutoIndexes(),
+                    [],
+                    $type->isList()
+                );
+            }
+
+            if ($type instanceof ArrayType) {
+                return new ArrayType($type->getKeyType(), $traverse($type->getItemType()));
+            }
+
+            return TypeCombinator::removeNull($type);
+        });
+    }
+
+}

vendor/composer/pcre/src/PHPStan/PregMatchParameterOutTypeExtension.php

@@ -0,0 +1,65 @@
+<?php declare(strict_types=1);
+
+namespace Composer\Pcre\PHPStan;
+
+use Composer\Pcre\Preg;
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use PHPStan\Type\StaticMethodParameterOutTypeExtension;
+use PHPStan\Type\Type;
+
+final class PregMatchParameterOutTypeExtension implements StaticMethodParameterOutTypeExtension
+{
+    /**
+     * @var RegexArrayShapeMatcher
+     */
+    private $regexShapeMatcher;
+
+    public function __construct(
+        RegexArrayShapeMatcher $regexShapeMatcher
+    )
+    {
+        $this->regexShapeMatcher = $regexShapeMatcher;
+    }
+
+    public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
+    {
+        return
+            $methodReflection->getDeclaringClass()->getName() === Preg::class
+            && in_array($methodReflection->getName(), [
+                'match', 'isMatch', 'matchStrictGroups', 'isMatchStrictGroups',
+                'matchAll', 'isMatchAll', 'matchAllStrictGroups', 'isMatchAllStrictGroups'
+            ], true)
+            && $parameter->getName() === 'matches';
+    }
+
+    public function getParameterOutTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type
+    {
+        $args = $methodCall->getArgs();
+        $patternArg = $args[0] ?? null;
+        $matchesArg = $args[2] ?? null;
+        $flagsArg = $args[3] ?? null;
+
+        if (
+            $patternArg === null || $matchesArg === null
+        ) {
+            return null;
+        }
+
+        $flagsType = PregMatchFlags::getType($flagsArg, $scope);
+        if ($flagsType === null) {
+            return null;
+        }
+
+        if (stripos($methodReflection->getName(), 'matchAll') !== false) {
+            return $this->regexShapeMatcher->matchAllExpr($patternArg->value, $flagsType, TrinaryLogic::createMaybe(), $scope);
+        }
+
+        return $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createMaybe(), $scope);
+    }
+
+}

vendor/composer/pcre/src/PHPStan/PregMatchTypeSpecifyingExtension.php

@@ -0,0 +1,105 @@
+<?php declare(strict_types=1);
+
+namespace Composer\Pcre\PHPStan;
+
+use Composer\Pcre\Preg;
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeSpecifier;
+use PHPStan\Analyser\TypeSpecifierAwareExtension;
+use PHPStan\Analyser\TypeSpecifierContext;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use PHPStan\Type\StaticMethodTypeSpecifyingExtension;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\Type;
+
+final class PregMatchTypeSpecifyingExtension implements StaticMethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
+{
+    /**
+     * @var TypeSpecifier
+     */
+    private $typeSpecifier;
+
+    /**
+     * @var RegexArrayShapeMatcher
+     */
+    private $regexShapeMatcher;
+
+    public function __construct(RegexArrayShapeMatcher $regexShapeMatcher)
+    {
+        $this->regexShapeMatcher = $regexShapeMatcher;
+    }
+
+    public function setTypeSpecifier(TypeSpecifier $typeSpecifier): void
+    {
+        $this->typeSpecifier = $typeSpecifier;
+    }
+
+    public function getClass(): string
+    {
+        return Preg::class;
+    }
+
+    public function isStaticMethodSupported(MethodReflection $methodReflection, StaticCall $node, TypeSpecifierContext $context): bool
+    {
+        return in_array($methodReflection->getName(), [
+                'match', 'isMatch', 'matchStrictGroups', 'isMatchStrictGroups',
+                'matchAll', 'isMatchAll', 'matchAllStrictGroups', 'isMatchAllStrictGroups'
+            ], true)
+            && !$context->null();
+    }
+
+    public function specifyTypes(MethodReflection $methodReflection, StaticCall $node, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
+    {
+        $args = $node->getArgs();
+        $patternArg = $args[0] ?? null;
+        $matchesArg = $args[2] ?? null;
+        $flagsArg = $args[3] ?? null;
+
+        if (
+            $patternArg === null || $matchesArg === null
+        ) {
+            return new SpecifiedTypes();
+        }
+
+        $flagsType = PregMatchFlags::getType($flagsArg, $scope);
+        if ($flagsType === null) {
+            return new SpecifiedTypes();
+        }
+
+        if (stripos($methodReflection->getName(), 'matchAll') !== false) {
+            $matchedType = $this->regexShapeMatcher->matchAllExpr($patternArg->value, $flagsType, TrinaryLogic::createFromBoolean($context->true()), $scope);
+        } else {
+            $matchedType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createFromBoolean($context->true()), $scope);
+        }
+
+        if ($matchedType === null) {
+            return new SpecifiedTypes();
+        }
+
+        if (
+            in_array($methodReflection->getName(), ['matchStrictGroups', 'isMatchStrictGroups', 'matchAllStrictGroups', 'isMatchAllStrictGroups'], true)
+        ) {
+            $matchedType = PregMatchFlags::removeNullFromMatches($matchedType);
+        }
+
+        $overwrite = false;
+        if ($context->false()) {
+            $overwrite = true;
+            $context = $context->negate();
+        }
+
+        return $this->typeSpecifier->create(
+            $matchesArg->value,
+            $matchedType,
+            $context,
+            $overwrite,
+            $scope,
+            $node
+        );
+    }
+}

vendor/composer/pcre/src/PHPStan/PregReplaceCallbackClosureTypeExtension.php

@@ -0,0 +1,91 @@
+<?php declare(strict_types=1);
+
+namespace Composer\Pcre\PHPStan;
+
+use Composer\Pcre\Preg;
+use Composer\Pcre\Regex;
+use PhpParser\Node\Expr\StaticCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Reflection\Native\NativeParameterReflection;
+use PHPStan\Reflection\ParameterReflection;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\ClosureType;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use PHPStan\Type\StaticMethodParameterClosureTypeExtension;
+use PHPStan\Type\StringType;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\Type;
+
+final class PregReplaceCallbackClosureTypeExtension implements StaticMethodParameterClosureTypeExtension
+{
+    /**
+     * @var RegexArrayShapeMatcher
+     */
+    private $regexShapeMatcher;
+
+    public function __construct(RegexArrayShapeMatcher $regexShapeMatcher)
+    {
+        $this->regexShapeMatcher = $regexShapeMatcher;
+    }
+
+    public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool
+    {
+        return in_array($methodReflection->getDeclaringClass()->getName(), [Preg::class, Regex::class], true)
+            && in_array($methodReflection->getName(), ['replaceCallback', 'replaceCallbackStrictGroups'], true)
+            && $parameter->getName() === 'replacement';
+    }
+
+    public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type
+    {
+        $args = $methodCall->getArgs();
+        $patternArg = $args[0] ?? null;
+        $flagsArg = $args[5] ?? null;
+
+        if (
+            $patternArg === null
+        ) {
+            return null;
+        }
+
+        $flagsType = PregMatchFlags::getType($flagsArg, $scope);
+
+        $matchesType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createYes(), $scope);
+        if ($matchesType === null) {
+            return null;
+        }
+
+        if ($methodReflection->getName() === 'replaceCallbackStrictGroups' && count($matchesType->getConstantArrays()) === 1) {
+            $matchesType = $matchesType->getConstantArrays()[0];
+            $matchesType = new ConstantArrayType(
+                $matchesType->getKeyTypes(),
+                array_map(static function (Type $valueType): Type {
+                    if (count($valueType->getConstantArrays()) === 1) {
+                        $valueTypeArray = $valueType->getConstantArrays()[0];
+                        return new ConstantArrayType(
+                            $valueTypeArray->getKeyTypes(),
+                            array_map(static function (Type $valueType): Type {
+                                return TypeCombinator::removeNull($valueType);
+                            }, $valueTypeArray->getValueTypes()),
+                            $valueTypeArray->getNextAutoIndexes(),
+                            [],
+                            $valueTypeArray->isList()
+                        );
+                    }
+                    return TypeCombinator::removeNull($valueType);
+                }, $matchesType->getValueTypes()),
+                $matchesType->getNextAutoIndexes(),
+                [],
+                $matchesType->isList()
+            );
+        }
+
+        return new ClosureType(
+            [
+                new NativeParameterReflection($parameter->getName(), $parameter->isOptional(), $matchesType, $parameter->passedByReference(), $parameter->isVariadic(), $parameter->getDefaultValue()),
+            ],
+            new StringType()
+        );
+    }
+}

vendor/composer/pcre/src/PHPStan/UnsafeStrictGroupsCallRule.php

@@ -0,0 +1,112 @@
+<?php declare(strict_types=1);
+
+namespace Composer\Pcre\PHPStan;
+
+use Composer\Pcre\Preg;
+use Composer\Pcre\Regex;
+use PhpParser\Node;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Name\FullyQualified;
+use PHPStan\Analyser\Scope;
+use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\ObjectType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\Php\RegexArrayShapeMatcher;
+use function sprintf;
+
+/**
+ * @implements Rule<StaticCall>
+ */
+final class UnsafeStrictGroupsCallRule implements Rule
+{
+    /**
+     * @var RegexArrayShapeMatcher
+     */
+    private $regexShapeMatcher;
+
+    public function __construct(RegexArrayShapeMatcher $regexShapeMatcher)
+    {
+        $this->regexShapeMatcher = $regexShapeMatcher;
+    }
+
+    public function getNodeType(): string
+    {
+        return StaticCall::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (!$node->class instanceof FullyQualified) {
+            return [];
+        }
+        $isRegex = $node->class->toString() === Regex::class;
+        $isPreg = $node->class->toString() === Preg::class;
+        if (!$isRegex && !$isPreg) {
+            return [];
+        }
+        if (!$node->name instanceof Node\Identifier || !in_array($node->name->name, ['matchStrictGroups', 'isMatchStrictGroups', 'matchAllStrictGroups', 'isMatchAllStrictGroups'], true)) {
+            return [];
+        }
+
+        $args = $node->getArgs();
+        if (!isset($args[0])) {
+            return [];
+        }
+
+        $patternArg = $args[0] ?? null;
+        if ($isPreg) {
+            if (!isset($args[2])) { // no matches set, skip as the matches won't be used anyway
+                return [];
+            }
+            $flagsArg = $args[3] ?? null;
+        } else {
+            $flagsArg = $args[2] ?? null;
+        }
+
+        if ($patternArg === null) {
+            return [];
+        }
+
+        $flagsType = PregMatchFlags::getType($flagsArg, $scope);
+        if ($flagsType === null) {
+            return [];
+        }
+
+        $matchedType = $this->regexShapeMatcher->matchExpr($patternArg->value, $flagsType, TrinaryLogic::createYes(), $scope);
+        if ($matchedType === null) {
+            return [
+                RuleErrorBuilder::message(sprintf('The %s call is potentially unsafe as $matches\' type could not be inferred.', $node->name->name))
+                    ->identifier('composerPcre.maybeUnsafeStrictGroups')
+                    ->build(),
+            ];
+        }
+
+        if (count($matchedType->getConstantArrays()) === 1) {
+            $matchedType = $matchedType->getConstantArrays()[0];
+            $nullableGroups = [];
+            foreach ($matchedType->getValueTypes() as $index => $type) {
+                if (TypeCombinator::containsNull($type)) {
+                    $nullableGroups[] = $matchedType->getKeyTypes()[$index]->getValue();
+                }
+            }
+
+            if (\count($nullableGroups) > 0) {
+                return [
+                    RuleErrorBuilder::message(sprintf(
+                        'The %s call is unsafe as match group%s "%s" %s optional and may be null.',
+                        $node->name->name,
+                        \count($nullableGroups) > 1 ? 's' : '',
+                        implode('", "', $nullableGroups),
+                        \count($nullableGroups) > 1 ? 'are' : 'is'
+                    ))->identifier('composerPcre.unsafeStrictGroups')->build(),
+                ];
+            }
+        }
+
+        return [];
+    }
+}

vendor/fidry/cpu-core-counter/.envrc

@@ -0,0 +1,5 @@
+use nix --packages \
+  gnumake \
+  yamllint
+
+source_env_if_exists .envrc.local

vendor/fidry/cpu-core-counter/src/Finder/EnvVariableFinder.php

@@ -0,0 +1,69 @@
+<?php
+
+/*
+ * This file is part of the Fidry CPUCounter Config package.
+ *
+ * (c) Théo FIDRY <theo.fidry@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Fidry\CpuCoreCounter\Finder;
+
+use function getenv;
+use function preg_match;
+use function sprintf;
+use function var_export;
+
+final class EnvVariableFinder implements CpuCoreFinder
+{
+    /** @var string */
+    private $environmentVariableName;
+
+    public function __construct(string $environmentVariableName)
+    {
+        $this->environmentVariableName = $environmentVariableName;
+    }
+
+    public function diagnose(): string
+    {
+        $value = getenv($this->environmentVariableName);
+
+        return sprintf(
+            'parse(getenv(%s)=%s)=%s',
+            $this->environmentVariableName,
+            var_export($value, true),
+            self::isPositiveInteger($value) ? $value : 'null'
+        );
+    }
+
+    public function find(): ?int
+    {
+        $value = getenv($this->environmentVariableName);
+
+        return self::isPositiveInteger($value)
+            ? (int) $value
+            : null;
+    }
+
+    public function toString(): string
+    {
+        return sprintf(
+            'getenv(%s)',
+            $this->environmentVariableName
+        );
+    }
+
+    /**
+     * @param string|false $value
+     */
+    private static function isPositiveInteger($value): bool
+    {
+        return false !== $value
+            && 1 === preg_match('/^\d+$/', $value)
+            && (int) $value > 0;
+    }
+}

vendor/fidry/cpu-core-counter/src/ParallelisationResult.php

@@ -0,0 +1,87 @@
+<?php
+
+/*
+ * This file is part of the Fidry CPUCounter Config package.
+ *
+ * (c) Théo FIDRY <theo.fidry@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Fidry\CpuCoreCounter;
+
+/**
+ * @readonly
+ */
+final class ParallelisationResult
+{
+    /**
+     * @var positive-int|0
+     */
+    public $passedReservedCpus;
+
+    /**
+     * @var non-zero-int|null
+     */
+    public $passedCountLimit;
+
+    /**
+     * @var float|null
+     */
+    public $passedLoadLimit;
+
+    /**
+     * @var float|null
+     */
+    public $passedSystemLoadAverage;
+
+    /**
+     * @var non-zero-int|null
+     */
+    public $correctedCountLimit;
+
+    /**
+     * @var float|null
+     */
+    public $correctedSystemLoadAverage;
+
+    /**
+     * @var positive-int
+     */
+    public $totalCoresCount;
+
+    /**
+     * @var positive-int
+     */
+    public $availableCpus;
+
+    /**
+     * @param positive-int|0    $passedReservedCpus
+     * @param non-zero-int|null $passedCountLimit
+     * @param non-zero-int|null $correctedCountLimit
+     * @param positive-int      $totalCoresCount
+     * @param positive-int      $availableCpus
+     */
+    public function __construct(
+        int $passedReservedCpus,
+        ?int $passedCountLimit,
+        ?float $passedLoadLimit,
+        ?float $passedSystemLoadAverage,
+        ?int $correctedCountLimit,
+        ?float $correctedSystemLoadAverage,
+        int $totalCoresCount,
+        int $availableCpus
+    ) {
+        $this->passedReservedCpus = $passedReservedCpus;
+        $this->passedCountLimit = $passedCountLimit;
+        $this->passedLoadLimit = $passedLoadLimit;
+        $this->passedSystemLoadAverage = $passedSystemLoadAverage;
+        $this->correctedCountLimit = $correctedCountLimit;
+        $this->correctedSystemLoadAverage = $correctedSystemLoadAverage;
+        $this->totalCoresCount = $totalCoresCount;
+        $this->availableCpus = $availableCpus;
+    }
+}

vendor/friendsofphp/php-cs-fixer/src/Fixer/ConfigurableFixerTrait.php

@@ -0,0 +1,127 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer;
+
+use PhpCsFixer\ConfigurationException\InvalidFixerConfigurationException;
+use PhpCsFixer\ConfigurationException\InvalidForEnvFixerConfigurationException;
+use PhpCsFixer\ConfigurationException\RequiredFixerConfigurationException;
+use PhpCsFixer\Console\Application;
+use PhpCsFixer\FixerConfiguration\DeprecatedFixerOption;
+use PhpCsFixer\FixerConfiguration\FixerConfigurationResolverInterface;
+use PhpCsFixer\FixerConfiguration\InvalidOptionsForEnvException;
+use PhpCsFixer\Utils;
+use Symfony\Component\OptionsResolver\Exception\ExceptionInterface;
+use Symfony\Component\OptionsResolver\Exception\MissingOptionsException;
+
+/**
+ * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * @internal
+ *
+ * @template TFixerInputConfig of array<string, mixed>
+ * @template TFixerComputedConfig of array<string, mixed>
+ */
+trait ConfigurableFixerTrait
+{
+    /**
+     * @var null|TFixerComputedConfig
+     */
+    protected $configuration;
+
+    /**
+     * @var null|FixerConfigurationResolverInterface
+     */
+    private $configurationDefinition;
+
+    /**
+     * @param TFixerInputConfig $configuration
+     */
+    final public function configure(array $configuration): void
+    {
+        $this->configurePreNormalisation($configuration);
+
+        foreach ($this->getConfigurationDefinition()->getOptions() as $option) {
+            if (!$option instanceof DeprecatedFixerOption) {
+                continue;
+            }
+
+            $name = $option->getName();
+            if (\array_key_exists($name, $configuration)) {
+                Utils::triggerDeprecation(new \InvalidArgumentException(\sprintf(
+                    'Option "%s" for rule "%s" is deprecated and will be removed in version %d.0. %s',
+                    $name,
+                    $this->getName(),
+                    Application::getMajorVersion() + 1,
+                    str_replace('`', '"', $option->getDeprecationMessage())
+                )));
+            }
+        }
+
+        try {
+            $this->configuration = $this->getConfigurationDefinition()->resolve($configuration); // @phpstan-ignore-line ->configuration typehint is autogenerated base on ConfigurationDefinition
+        } catch (MissingOptionsException $exception) {
+            throw new RequiredFixerConfigurationException(
+                $this->getName(),
+                \sprintf('Missing required configuration: %s', $exception->getMessage()),
+                $exception
+            );
+        } catch (InvalidOptionsForEnvException $exception) {
+            throw new InvalidForEnvFixerConfigurationException(
+                $this->getName(),
+                \sprintf('Invalid configuration for env: %s', $exception->getMessage()),
+                $exception
+            );
+        } catch (ExceptionInterface $exception) {
+            throw new InvalidFixerConfigurationException(
+                $this->getName(),
+                \sprintf('Invalid configuration: %s', $exception->getMessage()),
+                $exception
+            );
+        }
+
+        $this->configurePostNormalisation();
+    }
+
+    final public function getConfigurationDefinition(): FixerConfigurationResolverInterface
+    {
+        if (null === $this->configurationDefinition) {
+            $this->configurationDefinition = $this->createConfigurationDefinition();
+        }
+
+        return $this->configurationDefinition;
+    }
+
+    abstract public function getName(): string;
+
+    /**
+     * One can override me.
+     *
+     * @param TFixerInputConfig $configuration
+     */
+    protected function configurePreNormalisation(array &$configuration): void
+    {
+        // 🤔 ideally this method won't be needed, maybe we can remove it over time
+    }
+
+    /**
+     * One can override me.
+     */
+    protected function configurePostNormalisation(): void
+    {
+        // 🤔 ideally this method won't be needed, maybe we can remove it over time
+    }
+
+    abstract protected function createConfigurationDefinition(): FixerConfigurationResolverInterface;
+}

vendor/friendsofphp/php-cs-fixer/src/Fixer/InternalFixerInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer;
+
+/**
+ * @internal
+ */
+interface InternalFixerInterface extends FixerInterface {}

vendor/friendsofphp/php-cs-fixer/src/Fixer/PhpUnit/PhpUnitAssertNewNamesFixer.php

@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\PhpUnit;
+
+use PhpCsFixer\Fixer\AbstractPhpUnitFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+/**
+ * @author Krzysztof Ciszewski <krzysztof@ciszew.ski>
+ */
+final class PhpUnitAssertNewNamesFixer extends AbstractPhpUnitFixer
+{
+    public function isRisky(): bool
+    {
+        return true;
+    }
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Rename deprecated PHPUnit assertions like `assertFileNotExists` to new methods like `assertFileDoesNotExist`.',
+            [
+                new CodeSample(
+                    '<?php
+final class MyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSomeTest()
+    {
+        $this->assertFileNotExists("test.php");
+        $this->assertNotIsWritable("path.php");
+    }
+}
+'
+                ),
+            ],
+            null,
+            'Fixer could be risky if one is overriding PHPUnit\'s native methods.'
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Must run after PhpUnitDedicateAssertFixer.
+     */
+    public function getPriority(): int
+    {
+        return -10;
+    }
+
+    protected function applyPhpUnitClassFix(Tokens $tokens, int $startIndex, int $endIndex): void
+    {
+        foreach ($this->getPreviousAssertCall($tokens, $startIndex, $endIndex) as $assertCall) {
+            $this->fixAssertNewNames($tokens, $assertCall);
+        }
+    }
+
+    /**
+     * @param array{
+     *     index: int,
+     *     loweredName: string,
+     *     openBraceIndex: int,
+     *     closeBraceIndex: int,
+     * } $assertCall
+     */
+    private function fixAssertNewNames(Tokens $tokens, array $assertCall): void
+    {
+        $replacements = [
+            'assertnotisreadable' => 'assertIsNotReadable',
+            'assertnotiswritable' => 'assertIsNotWritable',
+            'assertdirectorynotexists' => 'assertDirectoryDoesNotExist',
+            'assertfilenotexists' => 'assertFileDoesNotExist',
+            'assertdirectorynotisreadable' => 'assertDirectoryIsNotReadable',
+            'assertdirectorynotiswritable' => 'assertDirectoryIsNotWriteable',
+            'assertfilenotisreadable' => 'assertFileIsNotReadable',
+            'assertfilenotiswritable' => 'assertFileIsNotWriteable',
+            'assertregexp' => 'assertMatchesRegularExpression',
+            'assertnotregexp' => 'assertDoesNotMatchRegularExpression',
+        ];
+        $replacement = $replacements[$assertCall['loweredName']] ?? null;
+
+        if (null === $replacement) {
+            return;
+        }
+
+        $tokens[$assertCall['index']] = new Token([
+            T_STRING,
+            $replacement,
+        ]);
+    }
+}

vendor/friendsofphp/php-cs-fixer/src/RuleSet/Sets/PHPUnit91MigrationRiskySet.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\RuleSet\Sets;
+
+use PhpCsFixer\RuleSet\AbstractMigrationSetDescription;
+
+/**
+ * @internal
+ */
+final class PHPUnit91MigrationRiskySet extends AbstractMigrationSetDescription
+{
+    public function getRules(): array
+    {
+        return [
+            '@PHPUnit84Migration:risky' => true,
+            'php_unit_assert_new_names' => true,
+        ];
+    }
+}

vendor/hyperf/contract/src/CanBeEscapedWhenCastToString.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Contract;
+
+interface CanBeEscapedWhenCastToString
+{
+    /**
+     * Indicate that the object's string representation should be escaped when __toString is invoked.
+     *
+     * @param bool $escape
+     * @return $this
+     */
+    public function escapeWhenCastingToString($escape = true);
+}

vendor/hyperf/database/src/Exception/ClassMorphViolationException.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Database\Exception;
+
+use RuntimeException;
+
+class ClassMorphViolationException extends RuntimeException
+{
+    /**
+     * The name of the affected Eloquent model.
+     */
+    public string $model;
+
+    /**
+     * Create a new exception instance.
+     */
+    public function __construct(object $model)
+    {
+        $class = get_class($model);
+
+        parent::__construct("No morph map defined for model [{$class}].");
+
+        $this->model = $class;
+    }
+}

vendor/hyperf/framework/src/Logger/ConsoleLogger.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Framework\Logger;
+
+use Hyperf\Contract\StdoutLoggerInterface;
+use Symfony\Component\Console\Logger\ConsoleLogger as SymfonyConsoleLogger;
+use Symfony\Component\Console\Output\ConsoleOutput;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class ConsoleLogger extends SymfonyConsoleLogger implements StdoutLoggerInterface
+{
+    public function __construct(?OutputInterface $output = null, array $verbosityLevelMap = [], array $formatLevelMap = [])
+    {
+        $output = $output ?? new ConsoleOutput(
+            (function (): int {
+                $argv = $_SERVER['argv'] ?? [];
+                $argv = is_string($argv) ? explode(' ', $argv) : $argv;
+
+                return match (true) {
+                    in_array('--quiet', $argv), in_array('-q', $argv) => OutputInterface::VERBOSITY_QUIET,
+                    in_array('-vvv', $argv) => OutputInterface::VERBOSITY_DEBUG,
+                    in_array('-vv', $argv) => OutputInterface::VERBOSITY_VERY_VERBOSE,
+                    in_array('-v', $argv) => OutputInterface::VERBOSITY_VERBOSE,
+                    default => match ((int) getenv('SHELL_VERBOSITY')) {
+                        -1 => OutputInterface::VERBOSITY_QUIET,
+                        1 => OutputInterface::VERBOSITY_VERBOSE,
+                        2 => OutputInterface::VERBOSITY_VERY_VERBOSE,
+                        3 => OutputInterface::VERBOSITY_DEBUG,
+                        default => OutputInterface::VERBOSITY_NORMAL,
+                    },
+                };
+            })()
+        );
+
+        parent::__construct($output, $verbosityLevelMap, $formatLevelMap);
+    }
+}

vendor/hyperf/support/src/DotenvManager.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Support;
+
+use Dotenv\Dotenv;
+use Dotenv\Repository\Adapter\AdapterInterface;
+use Dotenv\Repository\Adapter\PutenvAdapter;
+use Dotenv\Repository\RepositoryBuilder;
+
+class DotenvManager
+{
+    protected static AdapterInterface $adapter;
+
+    protected static Dotenv $dotenv;
+
+    protected static array $cachedValues;
+
+    public static function load(array $paths): void
+    {
+        if (isset(static::$cachedValues)) {
+            return;
+        }
+
+        static::$cachedValues = static::getDotenv($paths)->load();
+    }
+
+    public static function reload(array $paths, bool $force = false): void
+    {
+        if (! isset(static::$cachedValues)) {
+            static::load($paths);
+
+            return;
+        }
+
+        foreach (static::$cachedValues as $deletedEntry => $value) {
+            static::getAdapter()->delete($deletedEntry);
+        }
+
+        static::$cachedValues = static::getDotenv($paths, $force)->load();
+    }
+
+    protected static function getDotenv(array $paths, bool $force = false): Dotenv
+    {
+        if (isset(static::$dotenv) && ! $force) {
+            return static::$dotenv;
+        }
+
+        return static::$dotenv = Dotenv::create(
+            RepositoryBuilder::createWithNoAdapters()
+                ->addAdapter(static::getAdapter($force))
+                ->immutable()
+                ->make(),
+            $paths
+        );
+    }
+
+    protected static function getAdapter(bool $force = false): AdapterInterface
+    {
+        if (isset(static::$adapter) && ! $force) {
+            return static::$adapter;
+        }
+
+        return static::$adapter = PutenvAdapter::create()->get();
+    }
+}

vendor/hyperf/watcher/src/Event/BeforeServerRestart.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Watcher\Event;
+
+class BeforeServerRestart
+{
+    public function __construct(public string $pid)
+    {
+    }
+}

vendor/hyperf/watcher/src/Listener/ReloadDotenvListener.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Watcher\Listener;
+
+use Hyperf\Event\Contract\ListenerInterface;
+use Hyperf\Support\DotenvManager;
+use Hyperf\Watcher\Event\BeforeServerRestart;
+use Psr\Container\ContainerInterface;
+
+final class ReloadDotenvListener implements ListenerInterface
+{
+    public function __construct(protected ContainerInterface $container)
+    {
+    }
+
+    public function listen(): array
+    {
+        return [
+            BeforeServerRestart::class,
+        ];
+    }
+
+    public function process(object $event): void
+    {
+        $this->reloadDotenv();
+    }
+
+    private function reloadDotenv(): void
+    {
+        if (file_exists(BASE_PATH . '/.env')) {
+            DotenvManager::reload([BASE_PATH]);
+        }
+    }
+}

vendor/laminas/laminas-stdlib/.laminas-ci.json

@@ -0,0 +1,5 @@
+{
+    "ignore_php_platform_requirements": {
+        "8.4": true
+    }
+}

vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DatePeriodFilter.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace DeepCopy\TypeFilter\Date;
+
+use DatePeriod;
+use DeepCopy\TypeFilter\TypeFilter;
+
+/**
+ * @final
+ */
+class DatePeriodFilter implements TypeFilter
+{
+    /**
+     * {@inheritdoc}
+     *
+     * @param DatePeriod $element
+     *
+     * @see http://news.php.net/php.bugs/205076
+     */
+    public function apply($element)
+    {
+        $options = 0;
+        if (PHP_VERSION_ID >= 80200 && $element->include_end_date) {
+            $options |= DatePeriod::INCLUDE_END_DATE;
+        }
+        if (!$element->include_start_date) {
+            $options |= DatePeriod::EXCLUDE_START_DATE;
+        }
+
+        if ($element->getEndDate()) {
+            return new DatePeriod($element->getStartDate(), $element->getDateInterval(), $element->getEndDate(), $options);
+        }
+
+        if (PHP_VERSION_ID >= 70217) {
+            $recurrences = $element->getRecurrences();
+        } else {
+            $recurrences = $element->recurrences - $element->include_start_date;
+        }
+
+        return new DatePeriod($element->getStartDate(), $element->getDateInterval(), $recurrences, $options);
+    }
+}

vendor/phpunit/phpunit/src/Framework/MockObject/Exception/NoMoreReturnValuesConfiguredException.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject;
+
+use function sprintf;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class NoMoreReturnValuesConfiguredException extends \PHPUnit\Framework\Exception implements Exception
+{
+    public function __construct(Invocation $invocation, int $numberOfConfiguredReturnValues)
+    {
+        parent::__construct(
+            sprintf(
+                'Only %d return values have been configured for %s::%s()',
+                $numberOfConfiguredReturnValues,
+                $invocation->className(),
+                $invocation->methodName(),
+            ),
+        );
+    }
+}

vendor/phpunit/phpunit/src/Framework/MockObject/Generator/Exception/CannotUseAddMethodsException.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject\Generator;
+
+use function sprintf;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class CannotUseAddMethodsException extends \PHPUnit\Framework\Exception implements Exception
+{
+    public function __construct(string $type, string $methodName)
+    {
+        parent::__construct(
+            sprintf(
+                'Trying to configure method "%s" with addMethods(), but it exists in class "%s". Use onlyMethods() for methods that exist in the class',
+                $methodName,
+                $type,
+            ),
+        );
+    }
+}

vendor/phpunit/phpunit/src/Framework/MockObject/Generator/Exception/NameAlreadyInUseException.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Framework\MockObject\Generator;
+
+use function sprintf;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class NameAlreadyInUseException extends \PHPUnit\Framework\Exception implements Exception
+{
+    /**
+     * @psalm-param class-string|trait-string $name
+     */
+    public function __construct(string $name)
+    {
+        parent::__construct(
+            sprintf(
+                'The name "%s" is already in use',
+                $name,
+            ),
+        );
+    }
+}

vendor/phpunit/phpunit/src/Runner/Exception/DirectoryDoesNotExistException.php

@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Runner;
+
+use function sprintf;
+use RuntimeException;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class DirectoryDoesNotExistException extends RuntimeException implements Exception
+{
+    public function __construct(string $directory)
+    {
+        parent::__construct(
+            sprintf(
+                'Directory "%s" does not exist and could not be created',
+                $directory,
+            ),
+        );
+    }
+}

vendor/phpunit/phpunit/src/TextUI/Exception/CannotOpenSocketException.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\TextUI;
+
+use function sprintf;
+use RuntimeException;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class CannotOpenSocketException extends RuntimeException implements Exception
+{
+    public function __construct(string $hostname, int $port)
+    {
+        parent::__construct(
+            sprintf(
+                'Cannot open socket %s:%d',
+                $hostname,
+                $port,
+            ),
+        );
+    }
+}

vendor/phpunit/phpunit/src/Util/Http/Downloader.php

@@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Util\Http;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+interface Downloader
+{
+    /**
+     * @param non-empty-string $url
+     */
+    public function download(string $url): false|string;
+}

vendor/phpunit/phpunit/src/Util/Http/PhpDownloader.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+namespace PHPUnit\Util\Http;
+
+use function file_get_contents;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class PhpDownloader implements Downloader
+{
+    /**
+     * @param non-empty-string $url
+     */
+    public function download(string $url): false|string
+    {
+        return file_get_contents($url);
+    }
+}