FM / Resolver

/opt/cpanel/ea-wappspector/vendor/php-di/php-di/src/Definition/Resolver/

/opt/cpanel/ea-wappspector/vendor/php-di/php-di/src/Definition/Resolver

Name	Size	Mode	Actions
ArrayResolver.php	1997	0644	edit dl rm
DecoratorResolver.php	2242	0644	edit dl rm
DefinitionResolver.php	1245	0644	edit dl rm
EnvironmentVariableResolver.php	1867	0644	edit dl rm
FactoryResolver.php	3760	0644	edit dl rm
InstanceInjector.php	1392	0644	edit dl rm
ObjectCreator.php	6864	0644	edit dl rm
ParameterResolver.php	3613	0644	edit dl rm
ResolverDispatcher.php	4527	0644	edit dl rm

Edit: /opt/cpanel/ea-wappspector/vendor/php-di/php-di/src/Definition/Resolver/FactoryResolver.php (3760B)

<?php

declare(strict_types=1);

namespace DI\Definition\Resolver;

use DI\Definition\Definition;
use DI\Definition\Exception\InvalidDefinition;
use DI\Definition\FactoryDefinition;
use DI\Invoker\FactoryParameterResolver;
use Invoker\Exception\NotCallableException;
use Invoker\Exception\NotEnoughParametersException;
use Invoker\Invoker;
use Invoker\ParameterResolver\AssociativeArrayResolver;
use Invoker\ParameterResolver\DefaultValueResolver;
use Invoker\ParameterResolver\NumericArrayResolver;
use Invoker\ParameterResolver\ResolverChain;
use Psr\Container\ContainerInterface;

/**
 * Resolves a factory definition to a value.
 *
 * @template-implements DefinitionResolver<FactoryDefinition>
 *
 * @since 4.0
 * @author Matthieu Napoli <matthieu@mnapoli.fr>
 */
class FactoryResolver implements DefinitionResolver
{
    private ?Invoker $invoker = null;

/**
     * The resolver needs a container. This container will be passed to the factory as a parameter
     * so that the factory can access other entries of the container.
     */
    public function __construct(
        private ContainerInterface $container,
        private DefinitionResolver $resolver,
    ) {
    }

/**
     * Resolve a factory definition to a value.
     *
     * This will call the callable of the definition.
     *
     * @param FactoryDefinition $definition
     */
    public function resolve(Definition $definition, array $parameters = []) : mixed
    {
        if (! $this->invoker) {
            $parameterResolver = new ResolverChain([
                new AssociativeArrayResolver,
                new FactoryParameterResolver($this->container),
                new NumericArrayResolver,
                new DefaultValueResolver,
            ]);

$this->invoker = new Invoker($parameterResolver, $this->container);
        }

$callable = $definition->getCallable();

try {
            $providedParams = [$this->container, $definition];
            $extraParams = $this->resolveExtraParams($definition->getParameters());
            $providedParams = array_merge($providedParams, $extraParams, $parameters);

return $this->invoker->call($callable, $providedParams);
        } catch (NotCallableException $e) {
            // Custom error message to help debugging
            if (is_string($callable) && class_exists($callable) && method_exists($callable, '__invoke')) {
                throw new InvalidDefinition(sprintf(
                    'Entry "%s" cannot be resolved: factory %s. Invokable classes cannot be automatically resolved if autowiring is disabled on the container, you need to enable autowiring or define the entry manually.',
                    $definition->getName(),
                    $e->getMessage()
                ));
            }

throw new InvalidDefinition(sprintf(
                'Entry "%s" cannot be resolved: factory %s',
                $definition->getName(),
                $e->getMessage()
            ));
        } catch (NotEnoughParametersException $e) {
            throw new InvalidDefinition(sprintf(
                'Entry "%s" cannot be resolved: %s',
                $definition->getName(),
                $e->getMessage()
            ));
        }
    }

public function isResolvable(Definition $definition, array $parameters = []) : bool
    {
        return true;
    }

private function resolveExtraParams(array $params) : array
    {
        $resolved = [];
        foreach ($params as $key => $value) {
            // Nested definitions
            if ($value instanceof Definition) {
                $value = $this->resolver->resolve($value);
            }
            $resolved[$key] = $value;
        }

return $resolved;
    }
}

cmd: