vendor and env first commit

vendor/spatie/error-solutions/src/SolutionProviders/BadMethodCallSolutionProvider.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders;
+
+use BadMethodCallException;
+use Illuminate\Support\Collection;
+use ReflectionClass;
+use ReflectionMethod;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Throwable;
+
+class BadMethodCallSolutionProvider implements HasSolutionsForThrowable
+{
+    protected const REGEX = '/([a-zA-Z\\\\]+)::([a-zA-Z]+)/m';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof BadMethodCallException) {
+            return false;
+        }
+
+        if (is_null($this->getClassAndMethodFromExceptionMessage($throwable->getMessage()))) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            BaseSolution::create('Bad Method Call')
+            ->setSolutionDescription($this->getSolutionDescription($throwable)),
+        ];
+    }
+
+    public function getSolutionDescription(Throwable $throwable): string
+    {
+        if (! $this->canSolve($throwable)) {
+            return '';
+        }
+
+        /** @phpstan-ignore-next-line  */
+        extract($this->getClassAndMethodFromExceptionMessage($throwable->getMessage()), EXTR_OVERWRITE);
+
+        $possibleMethod = $this->findPossibleMethod($class ?? '', $method ?? '');
+
+        $class ??= 'UnknownClass';
+
+        return "Did you mean {$class}::{$possibleMethod?->name}() ?";
+    }
+
+    /**
+     * @param string $message
+     *
+     * @return null|array<string, mixed>
+     */
+    protected function getClassAndMethodFromExceptionMessage(string $message): ?array
+    {
+        if (! preg_match(self::REGEX, $message, $matches)) {
+            return null;
+        }
+
+        return [
+            'class' => $matches[1],
+            'method' => $matches[2],
+        ];
+    }
+
+    /**
+     * @param class-string $class
+     * @param string $invalidMethodName
+     *
+     * @return \ReflectionMethod|null
+     */
+    protected function findPossibleMethod(string $class, string $invalidMethodName): ?ReflectionMethod
+    {
+        return $this->getAvailableMethods($class)
+            ->sortByDesc(function (ReflectionMethod $method) use ($invalidMethodName) {
+                similar_text($invalidMethodName, $method->name, $percentage);
+
+                return $percentage;
+            })->first();
+    }
+
+    /**
+     * @param class-string $class
+     *
+     * @return \Illuminate\Support\Collection<int, ReflectionMethod>
+     */
+    protected function getAvailableMethods(string $class): Collection
+    {
+        $class = new ReflectionClass($class);
+
+        return Collection::make($class->getMethods());
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/DefaultDbNameSolutionProvider.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\QueryException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\SuggestUsingCorrectDbNameSolution;
+use Throwable;
+
+class DefaultDbNameSolutionProvider implements HasSolutionsForThrowable
+{
+    const MYSQL_UNKNOWN_DATABASE_CODE = 1049;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof QueryException) {
+            return false;
+        }
+
+        if ($throwable->getCode() !== self::MYSQL_UNKNOWN_DATABASE_CODE) {
+            return false;
+        }
+
+        if (! in_array(env('DB_DATABASE'), ['homestead', 'laravel'])) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new SuggestUsingCorrectDbNameSolution()];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/GenericLaravelExceptionSolutionProvider.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Broadcasting\BroadcastException;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Support\Laravel\LaravelVersion;
+use Throwable;
+
+class GenericLaravelExceptionSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        return ! is_null($this->getSolutionTexts($throwable));
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        if (! $texts = $this->getSolutionTexts($throwable)) {
+            return [];
+        }
+
+        $solution = BaseSolution::create($texts['title'])
+            ->setSolutionDescription($texts['description'])
+            ->setDocumentationLinks($texts['links']);
+
+        return ([$solution]);
+    }
+
+    /**
+     * @param \Throwable $throwable
+     *
+     * @return array<string, mixed>|null
+     */
+    protected function getSolutionTexts(Throwable $throwable) : ?array
+    {
+        foreach ($this->getSupportedExceptions() as $supportedClass => $texts) {
+            if ($throwable instanceof $supportedClass) {
+                return $texts;
+            }
+        }
+
+        return null;
+    }
+
+    /** @return array<string, mixed> */
+    protected function getSupportedExceptions(): array
+    {
+        $majorVersion = LaravelVersion::major();
+
+        return
+        [
+            BroadcastException::class => [
+                'title' => 'Here are some links that might help solve this problem',
+                'description' => '',
+                'links' => [
+                    'Laravel docs on authentication' => "https://laravel.com/docs/{$majorVersion}.x/authentication",
+                ],
+            ],
+        ];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/IncorrectValetDbCredentialsSolutionProvider.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\QueryException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\UseDefaultValetDbCredentialsSolution;
+use Throwable;
+
+class IncorrectValetDbCredentialsSolutionProvider implements HasSolutionsForThrowable
+{
+    const MYSQL_ACCESS_DENIED_CODE = 1045;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (PHP_OS !== 'Darwin') {
+            return false;
+        }
+
+        if (! $throwable instanceof QueryException) {
+            return false;
+        }
+
+        if (! $this->isAccessDeniedCode($throwable->getCode())) {
+            return false;
+        }
+
+        if (! $this->envFileExists()) {
+            return false;
+        }
+
+        if (! $this->isValetInstalled()) {
+            return false;
+        }
+
+        if ($this->usingCorrectDefaultCredentials()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new UseDefaultValetDbCredentialsSolution()];
+    }
+
+    protected function envFileExists(): bool
+    {
+        return file_exists(base_path('.env'));
+    }
+
+    protected function isAccessDeniedCode(string $code): bool
+    {
+        return $code === static::MYSQL_ACCESS_DENIED_CODE;
+    }
+
+    protected function isValetInstalled(): bool
+    {
+        return file_exists('/usr/local/bin/valet');
+    }
+
+    protected function usingCorrectDefaultCredentials(): bool
+    {
+        return env('DB_USERNAME') === 'root' && env('DB_PASSWORD') === '';
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/InvalidRouteActionSolutionProvider.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Support\Str;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Support\Laravel\Composer\ComposerClassMap;
+use Spatie\ErrorSolutions\Support\Laravel\StringComparator;
+use Throwable;
+use UnexpectedValueException;
+
+class InvalidRouteActionSolutionProvider implements HasSolutionsForThrowable
+{
+    protected const REGEX = '/\[([a-zA-Z\\\\]+)\]/m';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof UnexpectedValueException) {
+            return false;
+        }
+
+        if (! preg_match(self::REGEX, $throwable->getMessage(), $matches)) {
+            return false;
+        }
+
+        return Str::startsWith($throwable->getMessage(), 'Invalid route action: ');
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        preg_match(self::REGEX, $throwable->getMessage(), $matches);
+
+        $invalidController = $matches[1] ?? null;
+
+        if (! $invalidController) {
+            return [];
+        }
+
+        $suggestedController = $this->findRelatedController($invalidController);
+
+        if ($suggestedController === $invalidController) {
+            return [
+                BaseSolution::create("`{$invalidController}` is not invokable.")
+                    ->setSolutionDescription("The controller class `{$invalidController}` is not invokable. Did you forget to add the `__invoke` method or is the controller's method missing in your routes file?"),
+            ];
+        }
+
+        if ($suggestedController) {
+            return [
+                BaseSolution::create("`{$invalidController}` was not found.")
+                    ->setSolutionDescription("Controller class `{$invalidController}` for one of your routes was not found. Did you mean `{$suggestedController}`?"),
+            ];
+        }
+
+        return [
+            BaseSolution::create("`{$invalidController}` was not found.")
+                ->setSolutionDescription("Controller class `{$invalidController}` for one of your routes was not found. Are you sure this controller exists and is imported correctly?"),
+        ];
+    }
+
+    protected function findRelatedController(string $invalidController): ?string
+    {
+        $composerClassMap = app(ComposerClassMap::class);
+
+        $controllers = collect($composerClassMap->listClasses())
+            ->filter(function (string $file, string $fqcn) {
+                return Str::endsWith($fqcn, 'Controller');
+            })
+            ->mapWithKeys(function (string $file, string $fqcn) {
+                return [$fqcn => class_basename($fqcn)];
+            })
+            ->toArray();
+
+        $basenameMatch = StringComparator::findClosestMatch($controllers, $invalidController, 4);
+
+        $controllers = array_flip($controllers);
+
+        $fqcnMatch = StringComparator::findClosestMatch($controllers, $invalidController, 4);
+
+        return $fqcnMatch ?? $basenameMatch;
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/LazyLoadingViolationSolutionProvider.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\LazyLoadingViolationException;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Support\Laravel\LaravelVersion;
+use Throwable;
+
+class LazyLoadingViolationSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        if ($throwable instanceof LazyLoadingViolationException) {
+            return true;
+        }
+
+        if (! $previous = $throwable->getPrevious()) {
+            return false;
+        }
+
+        return $previous instanceof LazyLoadingViolationException;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        $majorVersion = LaravelVersion::major();
+
+        return [BaseSolution::create(
+            'Lazy loading was disabled to detect N+1 problems'
+        )
+            ->setSolutionDescription(
+                'Either avoid lazy loading the relation or allow lazy loading.'
+            )
+            ->setDocumentationLinks([
+                'Read the docs on preventing lazy loading' => "https://laravel.com/docs/{$majorVersion}.x/eloquent-relationships#preventing-lazy-loading",
+                'Watch a video on how to deal with the N+1 problem' => 'https://www.youtube.com/watch?v=ZE7KBeraVpc',
+            ]),];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/MissingAppKeySolutionProvider.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use RuntimeException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\GenerateAppKeySolution;
+use Throwable;
+
+class MissingAppKeySolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof RuntimeException) {
+            return false;
+        }
+
+        return $throwable->getMessage() === 'No application encryption key has been specified.';
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new GenerateAppKeySolution()];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/MissingColumnSolutionProvider.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\QueryException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\RunMigrationsSolution;
+use Throwable;
+
+class MissingColumnSolutionProvider implements HasSolutionsForThrowable
+{
+    /**
+     * See https://dev.mysql.com/doc/refman/8.0/en/server-error-reference.html#error_er_bad_field_error.
+     */
+    const MYSQL_BAD_FIELD_CODE = '42S22';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof QueryException) {
+            return false;
+        }
+
+        return  $this->isBadTableErrorCode($throwable->getCode());
+    }
+
+    protected function isBadTableErrorCode(string $code): bool
+    {
+        return $code === static::MYSQL_BAD_FIELD_CODE;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new RunMigrationsSolution('A column was not found')];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/MissingImportSolutionProvider.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\SuggestImportSolution;
+use Spatie\ErrorSolutions\Support\Laravel\Composer\ComposerClassMap;
+use Throwable;
+
+class MissingImportSolutionProvider implements HasSolutionsForThrowable
+{
+    protected ?string $foundClass;
+
+    protected ComposerClassMap $composerClassMap;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        $pattern = '/Class \"([^\s]+)\" not found/m';
+
+        if (! preg_match($pattern, $throwable->getMessage(), $matches)) {
+            return false;
+        }
+
+        $class = $matches[1];
+
+        $this->composerClassMap = new ComposerClassMap();
+
+        $this->search($class);
+
+        return ! is_null($this->foundClass);
+    }
+
+    /**
+     * @param \Throwable $throwable
+     *
+     * @return array<int, SuggestImportSolution>
+     */
+    public function getSolutions(Throwable $throwable): array
+    {
+        if (is_null($this->foundClass)) {
+            return [];
+        }
+
+        return [new SuggestImportSolution($this->foundClass)];
+    }
+
+    protected function search(string $missingClass): void
+    {
+        $this->foundClass = $this->composerClassMap->searchClassMap($missingClass);
+
+        if (is_null($this->foundClass)) {
+            $this->foundClass = $this->composerClassMap->searchPsrMaps($missingClass);
+        }
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/MissingLivewireComponentSolutionProvider.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Livewire\Exceptions\ComponentNotFoundException;
+use Livewire\LivewireComponentsFinder;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\LivewireDiscoverSolution;
+use Throwable;
+
+class MissingLivewireComponentSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $this->livewireIsInstalled()) {
+            return false;
+        }
+
+        if (! $throwable instanceof ComponentNotFoundException) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new LivewireDiscoverSolution('A Livewire component was not found')];
+    }
+
+    public function livewireIsInstalled(): bool
+    {
+        if (! class_exists(ComponentNotFoundException::class)) {
+            return false;
+        }
+        if (! class_exists(LivewireComponentsFinder::class)) {
+            return false;
+        }
+
+        return true;
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/MissingMixManifestSolutionProvider.php

@@ -0,0 +1,25 @@
+<?php
+
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Support\Str;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Throwable;
+
+class MissingMixManifestSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        return Str::startsWith($throwable->getMessage(), 'Mix manifest not found');
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            BaseSolution::create('Missing Mix Manifest File')
+                ->setSolutionDescription('Did you forget to run `npm install && npm run dev`?'),
+        ];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/MissingViteManifestSolutionProvider.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Support\Str;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Contracts\Solution;
+use Throwable;
+
+class MissingViteManifestSolutionProvider implements HasSolutionsForThrowable
+{
+    /** @var array<string, string> */
+    protected array $links = [
+        'Asset bundling with Vite' => 'https://laravel.com/docs/9.x/vite#running-vite',
+    ];
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        return Str::startsWith($throwable->getMessage(), 'Vite manifest not found');
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            $this->getSolution(),
+        ];
+    }
+
+    public function getSolution(): Solution
+    {
+        /** @var string */
+        $baseCommand = collect([
+            'pnpm-lock.yaml' => 'pnpm',
+            'yarn.lock' => 'yarn',
+        ])->first(fn ($_, $lockfile) => file_exists(base_path($lockfile)), 'npm run');
+
+        return app()->environment('local')
+            ? $this->getLocalSolution($baseCommand)
+            : $this->getProductionSolution($baseCommand);
+    }
+
+    protected function getLocalSolution(string $baseCommand): Solution
+    {
+        return BaseSolution::create('Start the development server')
+            ->setSolutionDescription("Run `{$baseCommand} dev` in your terminal and refresh the page.")
+            ->setDocumentationLinks($this->links);
+    }
+
+    protected function getProductionSolution(string $baseCommand): Solution
+    {
+        return BaseSolution::create('Build the production assets')
+            ->setSolutionDescription("Run `{$baseCommand} build` in your deployment script.")
+            ->setDocumentationLinks($this->links);
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/OpenAiSolutionProvider.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Support\Str;
+use OpenAI\Client;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\OpenAi\OpenAiSolutionProvider as BaseOpenAiSolutionProvider;
+use Throwable;
+
+class OpenAiSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! class_exists(Client::class)) {
+            return false;
+        }
+
+        if (config('error-solutions.open_ai_key') === null) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        $solutionProvider = new BaseOpenAiSolutionProvider(
+            openAiKey: config('error-solutions.open_ai_key'),
+            cache: cache()->store(config('cache.default')),
+            cacheTtlInSeconds: 60,
+            applicationType: 'Laravel ' . Str::before(app()->version(), '.'),
+            applicationPath: base_path(),
+            openAiModel: config('error-solutions.open_ai_model', 'gpt-3.5-turbo'),
+        );
+
+        return $solutionProvider->getSolutions($throwable);
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/RouteNotDefinedSolutionProvider.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Support\Facades\Route;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Support\Laravel\StringComparator;
+use Symfony\Component\Routing\Exception\RouteNotFoundException;
+use Throwable;
+
+class RouteNotDefinedSolutionProvider implements HasSolutionsForThrowable
+{
+    protected const REGEX = '/Route \[(.*)\] not defined/m';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof RouteNotFoundException) {
+            return false;
+        }
+
+        return (bool)preg_match(self::REGEX, $throwable->getMessage(), $matches);
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        preg_match(self::REGEX, $throwable->getMessage(), $matches);
+
+        $missingRoute = $matches[1] ?? '';
+
+        $suggestedRoute = $this->findRelatedRoute($missingRoute);
+
+        if ($suggestedRoute) {
+            return [
+                BaseSolution::create("{$missingRoute} was not defined.")
+                    ->setSolutionDescription("Did you mean `{$suggestedRoute}`?"),
+            ];
+        }
+
+        return [
+            BaseSolution::create("{$missingRoute} was not defined.")
+                ->setSolutionDescription('Are you sure that the route is defined'),
+        ];
+    }
+
+    protected function findRelatedRoute(string $missingRoute): ?string
+    {
+        Route::getRoutes()->refreshNameLookups();
+
+        return StringComparator::findClosestMatch(array_keys(Route::getRoutes()->getRoutesByName()), $missingRoute);
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/RunningLaravelDuskInProductionProvider.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Exception;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Throwable;
+
+class RunningLaravelDuskInProductionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof Exception) {
+            return false;
+        }
+
+        return $throwable->getMessage() === 'It is unsafe to run Dusk in production.';
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            BaseSolution::create()
+                ->setSolutionTitle('Laravel Dusk should not be run in production.')
+                ->setSolutionDescription('Install the dependencies with the `--no-dev` flag.'),
+
+            BaseSolution::create()
+                ->setSolutionTitle('Laravel Dusk can be run in other environments.')
+                ->setSolutionDescription('Consider setting the `APP_ENV` to something other than `production` like `local` for example.'),
+        ];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/SailNetworkSolutionProvider.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Throwable;
+
+class SailNetworkSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        return app()->runningInConsole()
+            && str_contains($throwable->getMessage(), 'php_network_getaddresses')
+            && file_exists(base_path('vendor/bin/sail'))
+            && file_exists(base_path('docker-compose.yml'))
+            && env('LARAVEL_SAIL') === null;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            BaseSolution::create('Network address not found')
+                ->setSolutionDescription('Did you mean to use `sail artisan`?')
+                ->setDocumentationLinks([
+                    'Sail: Executing Artisan Commands' => 'https://laravel.com/docs/sail#executing-artisan-commands',
+                ]),
+        ];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/TableNotFoundSolutionProvider.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\QueryException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\RunMigrationsSolution;
+use Throwable;
+
+class TableNotFoundSolutionProvider implements HasSolutionsForThrowable
+{
+    /**
+     * See https://dev.mysql.com/doc/refman/8.0/en/server-error-reference.html#error_er_bad_table_error.
+     */
+    const MYSQL_BAD_TABLE_CODE = '42S02';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof QueryException) {
+            return false;
+        }
+
+        return  $this->isBadTableErrorCode($throwable->getCode());
+    }
+
+    protected function isBadTableErrorCode(string $code): bool
+    {
+        return $code === static::MYSQL_BAD_TABLE_CODE;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new RunMigrationsSolution('A table was not found')];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/UndefinedLivewireMethodSolutionProvider.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Livewire\Exceptions\MethodNotFoundException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\SuggestLivewireMethodNameSolution;
+use Spatie\ErrorSolutions\Support\Laravel\LivewireComponentParser;
+use Throwable;
+
+class UndefinedLivewireMethodSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        return $throwable instanceof MethodNotFoundException;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        ['methodName' => $methodName, 'component' => $component] = $this->getMethodAndComponent($throwable);
+
+        if ($methodName === null || $component === null) {
+            return [];
+        }
+
+        $parsed = LivewireComponentParser::create($component);
+
+        return $parsed->getMethodNamesLike($methodName)
+            ->map(function (string $suggested) use ($parsed, $methodName) {
+                return new SuggestLivewireMethodNameSolution(
+                    $methodName,
+                    $parsed->getComponentClass(),
+                    $suggested
+                );
+            })
+            ->toArray();
+    }
+
+    /** @return array<string, string|null> */
+    protected function getMethodAndComponent(Throwable $throwable): array
+    {
+        preg_match_all('/\[([\d\w\-_]*)\]/m', $throwable->getMessage(), $matches, PREG_SET_ORDER);
+
+        return [
+            'methodName' => $matches[0][1] ?? null,
+            'component' => $matches[1][1] ?? null,
+        ];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/UndefinedLivewirePropertySolutionProvider.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Livewire\Exceptions\PropertyNotFoundException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\SuggestLivewirePropertyNameSolution;
+use Spatie\ErrorSolutions\Support\Laravel\LivewireComponentParser;
+use Throwable;
+
+class UndefinedLivewirePropertySolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        return $throwable instanceof PropertyNotFoundException;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        ['variable' => $variable, 'component' => $component] = $this->getMethodAndComponent($throwable);
+
+        if ($variable === null || $component === null) {
+            return [];
+        }
+
+        $parsed = LivewireComponentParser::create($component);
+
+        return $parsed->getPropertyNamesLike($variable)
+            ->map(function (string $suggested) use ($parsed, $variable) {
+                return new SuggestLivewirePropertyNameSolution(
+                    $variable,
+                    $parsed->getComponentClass(),
+                    '$'.$suggested
+                );
+            })
+            ->toArray();
+    }
+
+    /**
+     * @param \Throwable $throwable
+     *
+     * @return array<string, string|null>
+     */
+    protected function getMethodAndComponent(Throwable $throwable): array
+    {
+        preg_match_all('/\[([\d\w\-_\$]*)\]/m', $throwable->getMessage(), $matches, PREG_SET_ORDER, 0);
+
+        return [
+            'variable' => $matches[0][1] ?? null,
+            'component' => $matches[1][1] ?? null,
+        ];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/UndefinedViewVariableSolutionProvider.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Contracts\Solution;
+use Spatie\ErrorSolutions\Solutions\Laravel\MakeViewVariableOptionalSolution;
+use Spatie\ErrorSolutions\Solutions\Laravel\SuggestCorrectVariableNameSolution;
+use Spatie\LaravelFlare\Exceptions\ViewException as FlareViewException;
+use Spatie\LaravelIgnition\Exceptions\ViewException as IgnitionViewException;
+use Throwable;
+
+class UndefinedViewVariableSolutionProvider implements HasSolutionsForThrowable
+{
+    protected string $variableName;
+
+    protected string $viewFile;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof IgnitionViewException && ! $throwable instanceof FlareViewException) {
+            return false;
+        }
+
+        return $this->getNameAndView($throwable) !== null;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        $solutions = [];
+
+        /** @phpstan-ignore-next-line  */
+        extract($this->getNameAndView($throwable));
+
+        if (! isset($variableName)) {
+            return [];
+        }
+
+        if (isset($viewFile)) {
+            /** @phpstan-ignore-next-line  */
+            $solutions = $this->findCorrectVariableSolutions($throwable, $variableName, $viewFile);
+            $solutions[] = $this->findOptionalVariableSolution($variableName, $viewFile);
+        }
+
+
+        return $solutions;
+    }
+
+    /**
+     * @param IgnitionViewException|FlareViewException $throwable
+     * @param string $variableName
+     * @param string $viewFile
+     *
+     * @return array<int, \Spatie\ErrorSolutions\Contracts\Solution>
+     */
+    protected function findCorrectVariableSolutions(
+        IgnitionViewException|FlareViewException $throwable,
+        string $variableName,
+        string $viewFile
+    ): array {
+        return collect($throwable->getViewData())
+            ->map(function ($value, $key) use ($variableName) {
+                similar_text($variableName, $key, $percentage);
+
+                return ['match' => $percentage, 'value' => $value];
+            })
+            ->sortByDesc('match')
+            ->filter(fn ($var) => $var['match'] > 40)
+            ->keys()
+            ->map(fn ($suggestion) => new SuggestCorrectVariableNameSolution($variableName, $viewFile, $suggestion))
+            ->map(function ($solution) {
+                return $solution->isRunnable()
+                    ? $solution
+                    : BaseSolution::create($solution->getSolutionTitle())
+                        ->setSolutionDescription($solution->getSolutionDescription());
+            })
+            ->toArray();
+    }
+
+    protected function findOptionalVariableSolution(string $variableName, string $viewFile): Solution
+    {
+        $optionalSolution = new MakeViewVariableOptionalSolution($variableName, $viewFile);
+
+        return $optionalSolution->isRunnable()
+            ? $optionalSolution
+            : BaseSolution::create($optionalSolution->getSolutionTitle())
+                ->setSolutionDescription($optionalSolution->getSolutionDescription());
+    }
+
+    /**
+     * @param \Throwable $throwable
+     *
+     * @return array<string, string>|null
+     */
+    protected function getNameAndView(Throwable $throwable): ?array
+    {
+        $pattern = '/Undefined variable:? (.*?) \(View: (.*?)\)/';
+
+        preg_match($pattern, $throwable->getMessage(), $matches);
+
+        if (count($matches) === 3) {
+            [, $variableName, $viewFile] = $matches;
+            $variableName = ltrim($variableName, '$');
+
+            return compact('variableName', 'viewFile');
+        }
+
+        return null;
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/UnknownMariadbCollationSolutionProvider.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\QueryException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\SuggestUsingMariadbDatabaseSolution;
+use Throwable;
+
+class UnknownMariadbCollationSolutionProvider implements HasSolutionsForThrowable
+{
+    const MYSQL_UNKNOWN_COLLATION_CODE = 1273;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof QueryException) {
+            return false;
+        }
+
+        if ($throwable->getCode() !== self::MYSQL_UNKNOWN_COLLATION_CODE) {
+            return false;
+        }
+
+        return str_contains(
+            $throwable->getMessage(),
+            'Unknown collation: \'utf8mb4_uca1400_ai_ci\''
+        );
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new SuggestUsingMariadbDatabaseSolution()];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/UnknownMysql8CollationSolutionProvider.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Database\QueryException;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Solutions\Laravel\SuggestUsingMysql8DatabaseSolution;
+use Throwable;
+
+class UnknownMysql8CollationSolutionProvider implements HasSolutionsForThrowable
+{
+    const MYSQL_UNKNOWN_COLLATION_CODE = 1273;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof QueryException) {
+            return false;
+        }
+
+        if ($throwable->getCode() !== self::MYSQL_UNKNOWN_COLLATION_CODE) {
+            return false;
+        }
+
+        return str_contains(
+            $throwable->getMessage(),
+            'Unknown collation: \'utf8mb4_0900_ai_ci\''
+        );
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [new SuggestUsingMysql8DatabaseSolution()];
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/UnknownValidationSolutionProvider.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use BadMethodCallException;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
+use Illuminate\Validation\Validator;
+use ReflectionClass;
+use ReflectionMethod;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Support\Laravel\StringComparator;
+use Throwable;
+
+class UnknownValidationSolutionProvider implements HasSolutionsForThrowable
+{
+    protected const REGEX = '/Illuminate\\\\Validation\\\\Validator::(?P<method>validate(?!(Attribute|UsingCustomRule))[A-Z][a-zA-Z]+)/m';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof BadMethodCallException) {
+            return false;
+        }
+
+        return ! is_null($this->getMethodFromExceptionMessage($throwable->getMessage()));
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            BaseSolution::create()
+                ->setSolutionTitle('Unknown Validation Rule')
+                ->setSolutionDescription($this->getSolutionDescription($throwable)),
+        ];
+    }
+
+    protected function getSolutionDescription(Throwable $throwable): string
+    {
+        $method = (string)$this->getMethodFromExceptionMessage($throwable->getMessage());
+
+        $possibleMethod = StringComparator::findSimilarText(
+            $this->getAvailableMethods()->toArray(),
+            $method
+        );
+
+        if (empty($possibleMethod)) {
+            return '';
+        }
+
+        $rule = Str::snake(str_replace('validate', '', $possibleMethod));
+
+        return "Did you mean `{$rule}` ?";
+    }
+
+    protected function getMethodFromExceptionMessage(string $message): ?string
+    {
+        if (! preg_match(self::REGEX, $message, $matches)) {
+            return null;
+        }
+
+        return $matches['method'];
+    }
+
+    protected function getAvailableMethods(): Collection
+    {
+        $class = new ReflectionClass(Validator::class);
+
+        $extensions = Collection::make((app('validator')->make([], []))->extensions)
+            ->keys()
+            ->map(fn (string $extension) => 'validate'.Str::studly($extension));
+
+        return Collection::make($class->getMethods())
+            ->filter(fn (ReflectionMethod $method) => preg_match('/(validate(?!(Attribute|UsingCustomRule))[A-Z][a-zA-Z]+)/', $method->name))
+            ->map(fn (ReflectionMethod $method) => $method->name)
+            ->merge($extensions);
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/Laravel/ViewNotFoundSolutionProvider.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders\Laravel;
+
+use Illuminate\Support\Arr;
+use Illuminate\Support\Facades\View;
+use InvalidArgumentException;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Spatie\ErrorSolutions\Support\Laravel\StringComparator;
+use Spatie\Ignition\Exceptions\ViewException as IgnitionViewException;
+use Spatie\LaravelFlare\Exceptions\ViewException as FlareViewException;
+use Symfony\Component\Finder\Finder;
+use Symfony\Component\Finder\SplFileInfo;
+use Throwable;
+
+class ViewNotFoundSolutionProvider implements HasSolutionsForThrowable
+{
+    protected const REGEX = '/View \[(.*)\] not found/m';
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof InvalidArgumentException && (! $throwable instanceof IgnitionViewException || ! $throwable instanceof FlareViewException)) {
+            return false;
+        }
+
+        return (bool)preg_match(self::REGEX, $throwable->getMessage(), $matches);
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        preg_match(self::REGEX, $throwable->getMessage(), $matches);
+
+        $missingView = $matches[1] ?? null;
+
+        $suggestedView = $this->findRelatedView($missingView);
+
+        if ($suggestedView) {
+            return [
+                BaseSolution::create()
+                    ->setSolutionTitle("{$missingView} was not found.")
+                    ->setSolutionDescription("Did you mean `{$suggestedView}`?"),
+            ];
+        }
+
+        return [
+            BaseSolution::create()
+                ->setSolutionTitle("{$missingView} was not found.")
+                ->setSolutionDescription('Are you sure the view exists and is a `.blade.php` file?'),
+        ];
+    }
+
+    protected function findRelatedView(string $missingView): ?string
+    {
+        $views = $this->getAllViews();
+
+        return StringComparator::findClosestMatch($views, $missingView);
+    }
+
+    /** @return array<int, string> */
+    protected function getAllViews(): array
+    {
+        /** @var \Illuminate\View\FileViewFinder $fileViewFinder */
+        $fileViewFinder = View::getFinder();
+
+        $extensions = $fileViewFinder->getExtensions();
+
+        $viewsForHints = collect($fileViewFinder->getHints())
+            ->flatMap(function ($paths, string $namespace) use ($extensions) {
+                $paths = Arr::wrap($paths);
+
+                return collect($paths)
+                    ->flatMap(fn (string $path) => $this->getViewsInPath($path, $extensions))
+                    ->map(fn (string $view) => "{$namespace}::{$view}")
+                    ->toArray();
+            });
+
+        $viewsForViewPaths = collect($fileViewFinder->getPaths())
+            ->flatMap(fn (string $path) => $this->getViewsInPath($path, $extensions));
+
+        return $viewsForHints->merge($viewsForViewPaths)->toArray();
+    }
+
+    /**
+     * @param string $path
+     * @param array<int, string> $extensions
+     *
+     * @return array<int, string>
+     */
+    protected function getViewsInPath(string $path, array $extensions): array
+    {
+        $filePatterns = array_map(fn (string $extension) => "*.{$extension}", $extensions);
+
+        $extensionsWithDots = array_map(fn (string $extension) => ".{$extension}", $extensions);
+
+        $files = (new Finder())
+            ->in($path)
+            ->files();
+
+        foreach ($filePatterns as $filePattern) {
+            $files->name($filePattern);
+        }
+
+        $views = [];
+
+        foreach ($files as $file) {
+            if ($file instanceof SplFileInfo) {
+                $view = $file->getRelativePathname();
+                $view = str_replace($extensionsWithDots, '', $view);
+                $view = str_replace('/', '.', $view);
+                $views[] = $view;
+            }
+        }
+
+        return $views;
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/MergeConflictSolutionProvider.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders;
+
+use Illuminate\Support\Str;
+use ParseError;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Throwable;
+
+class MergeConflictSolutionProvider implements HasSolutionsForThrowable
+{
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! ($throwable instanceof ParseError)) {
+            return false;
+        }
+
+        if (! $this->hasMergeConflictExceptionMessage($throwable)) {
+            return false;
+        }
+
+        $file = (string)file_get_contents($throwable->getFile());
+
+        if (! str_contains($file, '=======')) {
+            return false;
+        }
+        if (! str_contains($file, '>>>>>>>')) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        $file = (string)file_get_contents($throwable->getFile());
+        preg_match('/\>\>\>\>\>\>\> (.*?)\n/', $file, $matches);
+        $source = $matches[1];
+
+        $target = $this->getCurrentBranch(basename($throwable->getFile()));
+
+        return [
+            BaseSolution::create("Merge conflict from branch '$source' into $target")
+                ->setSolutionDescription('You have a Git merge conflict. To undo your merge do `git reset --hard HEAD`'),
+        ];
+    }
+
+    protected function getCurrentBranch(string $directory): string
+    {
+        $branch = "'".trim((string)shell_exec("cd {$directory}; git branch | grep \\* | cut -d ' ' -f2"))."'";
+
+        if ($branch === "''") {
+            $branch = 'current branch';
+        }
+
+        return $branch;
+    }
+
+    protected function hasMergeConflictExceptionMessage(Throwable $throwable): bool
+    {
+        // For PHP 7.x and below
+        if (Str::startsWith($throwable->getMessage(), 'syntax error, unexpected \'<<\'')) {
+            return true;
+        }
+
+        // For PHP 8+
+        if (Str::startsWith($throwable->getMessage(), 'syntax error, unexpected token "<<"')) {
+            return true;
+        }
+
+        return false;
+    }
+}

vendor/spatie/error-solutions/src/SolutionProviders/UndefinedPropertySolutionProvider.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Spatie\ErrorSolutions\SolutionProviders;
+
+use ErrorException;
+use Illuminate\Support\Collection;
+use ReflectionClass;
+use ReflectionProperty;
+use Spatie\ErrorSolutions\Contracts\BaseSolution;
+use Spatie\ErrorSolutions\Contracts\HasSolutionsForThrowable;
+use Throwable;
+
+class UndefinedPropertySolutionProvider implements HasSolutionsForThrowable
+{
+    protected const REGEX = '/([a-zA-Z\\\\]+)::\$([a-zA-Z]+)/m';
+    protected const MINIMUM_SIMILARITY = 80;
+
+    public function canSolve(Throwable $throwable): bool
+    {
+        if (! $throwable instanceof ErrorException) {
+            return false;
+        }
+
+        if (is_null($this->getClassAndPropertyFromExceptionMessage($throwable->getMessage()))) {
+            return false;
+        }
+
+        if (! $this->similarPropertyExists($throwable)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getSolutions(Throwable $throwable): array
+    {
+        return [
+            BaseSolution::create('Unknown Property')
+            ->setSolutionDescription($this->getSolutionDescription($throwable)),
+        ];
+    }
+
+    public function getSolutionDescription(Throwable $throwable): string
+    {
+        if (! $this->canSolve($throwable) || ! $this->similarPropertyExists($throwable)) {
+            return '';
+        }
+
+        extract(
+            /** @phpstan-ignore-next-line */
+            $this->getClassAndPropertyFromExceptionMessage($throwable->getMessage()),
+            EXTR_OVERWRITE,
+        );
+
+        $possibleProperty = $this->findPossibleProperty($class ?? '', $property ?? '');
+
+        $class = $class ?? '';
+
+        return "Did you mean {$class}::\${$possibleProperty->name} ?";
+    }
+
+    protected function similarPropertyExists(Throwable $throwable): bool
+    {
+        /** @phpstan-ignore-next-line  */
+        extract($this->getClassAndPropertyFromExceptionMessage($throwable->getMessage()), EXTR_OVERWRITE);
+
+        $possibleProperty = $this->findPossibleProperty($class ?? '', $property ?? '');
+
+        return $possibleProperty !== null;
+    }
+
+    /**
+     * @param string $message
+     *
+     * @return null|array<string, string>
+     */
+    protected function getClassAndPropertyFromExceptionMessage(string $message): ?array
+    {
+        if (! preg_match(self::REGEX, $message, $matches)) {
+            return null;
+        }
+
+        return [
+            'class' => $matches[1],
+            'property' => $matches[2],
+        ];
+    }
+
+    /**
+     * @param class-string $class
+     * @param string $invalidPropertyName
+     *
+     * @return mixed
+     */
+    protected function findPossibleProperty(string $class, string $invalidPropertyName): mixed
+    {
+        return $this->getAvailableProperties($class)
+            ->sortByDesc(function (ReflectionProperty $property) use ($invalidPropertyName) {
+                similar_text($invalidPropertyName, $property->name, $percentage);
+
+                return $percentage;
+            })
+            ->filter(function (ReflectionProperty $property) use ($invalidPropertyName) {
+                similar_text($invalidPropertyName, $property->name, $percentage);
+
+                return $percentage >= self::MINIMUM_SIMILARITY;
+            })->first();
+    }
+
+    /**
+     * @param class-string $class
+     *
+     * @return Collection<int, ReflectionProperty>
+     */
+    protected function getAvailableProperties(string $class): Collection
+    {
+        $class = new ReflectionClass($class);
+
+        return Collection::make($class->getProperties());
+    }
+}