function ComposerRepository::loadAsyncPackages

@phpstan-param array<key-of<BasePackage::STABILITIES>, BasePackage::STABILITY_*>|null $acceptableStabilities

@phpstan-param array<string, BasePackage::STABILITY_*>|null $stabilityFlags

Parameters

array<string, ConstraintInterface|null> $packageNames array of package name => ConstraintInterface|null - if a constraint is provided, only: packages matching it will be loaded

array<string, int>|null $acceptableStabilities:

array<string, int>|null $stabilityFlags an array of package name => BasePackage::STABILITY_* value:

array<string, array<string, PackageInterface>> $alreadyLoaded:

Return value

array{namesFound: array<string, true>, packages: array<string, BasePackage>}

4 calls to ComposerRepository::loadAsyncPackages()

ComposerRepository::findPackage in vendor/composer/composer/src/Composer/Repository/ComposerRepository.php

@inheritDoc

ComposerRepository::findPackages in vendor/composer/composer/src/Composer/Repository/ComposerRepository.php

@inheritDoc

ComposerRepository::getPackages in vendor/composer/composer/src/Composer/Repository/ComposerRepository.php

@inheritDoc

ComposerRepository::loadPackages in vendor/composer/composer/src/Composer/Repository/ComposerRepository.php

@inheritDoc

File

vendor/composer/composer/src/Composer/Repository/ComposerRepository.php, line 1007

Class

ComposerRepository

@author Jordi Boggiano <j.boggiano@seld.be>

Namespace

Composer\Repository

Code

private function loadAsyncPackages(array $packageNames, ?array $acceptableStabilities = null, ?array $stabilityFlags = null, array $alreadyLoaded = []) : array {
    $this->loadRootServerFile();
    $packages = [];
    $namesFound = [];
    $promises = [];
    if (null === $this->lazyProvidersUrl) {
        throw new \LogicException('loadAsyncPackages only supports v2 protocol composer repos with a metadata-url');
    }
    // load ~dev versions of the packages as well if needed
    foreach ($packageNames as $name => $constraint) {
        if ($acceptableStabilities === null || $stabilityFlags === null || StabilityFilter::isPackageAcceptable($acceptableStabilities, $stabilityFlags, [
            $name,
        ], 'dev')) {
            $packageNames[$name . '~dev'] = $constraint;
        }
        // if only dev stability is requested, we skip loading the non dev file
        if (isset($acceptableStabilities['dev']) && count($acceptableStabilities) === 1 && count($stabilityFlags) === 0) {
            unset($packageNames[$name]);
        }
    }
    foreach ($packageNames as $name => $constraint) {
        $name = strtolower($name);
        $realName = Preg::replace('{~dev$}', '', $name);
        // skip platform packages, root package and composer-plugin-api
        if (PlatformRepository::isPlatformPackage($realName) || '__root__' === $realName) {
            continue;
        }
        $promises[] = $this->startCachedAsyncDownload($name, $realName)
            ->then(function (array $spec) use (&$packages, &$namesFound, $realName, $constraint, $acceptableStabilities, $stabilityFlags, $alreadyLoaded) : void {
            [
                $response,
                $packagesSource,
            ] = $spec;
            if (null === $response || !isset($response['packages'][$realName])) {
                return;
            }
            $versions = $response['packages'][$realName];
            if (isset($response['minified']) && $response['minified'] === 'composer/2.0') {
                $versions = MetadataMinifier::expand($versions);
            }
            $namesFound[$realName] = true;
            $versionsToLoad = [];
            foreach ($versions as $version) {
                if (!isset($version['version_normalized'])) {
                    $version['version_normalized'] = $this->versionParser
                        ->normalize($version['version']);
                }
                elseif ($version['version_normalized'] === VersionParser::DEFAULT_BRANCH_ALIAS) {
                    // handling of existing repos which need to remain composer v1 compatible, in case the version_normalized contained VersionParser::DEFAULT_BRANCH_ALIAS, we renormalize it
                    $version['version_normalized'] = $this->versionParser
                        ->normalize($version['version']);
                }
                // avoid loading packages which have already been loaded
                if (isset($alreadyLoaded[$realName][$version['version_normalized']])) {
                    continue;
                }
                if ($this->isVersionAcceptable($constraint, $realName, $version, $acceptableStabilities, $stabilityFlags)) {
                    $versionsToLoad[] = $version;
                }
            }
            $loadedPackages = $this->createPackages($versionsToLoad, $packagesSource);
            foreach ($loadedPackages as $package) {
                $package->setRepository($this);
                $packages[spl_object_hash($package)] = $package;
                if ($package instanceof AliasPackage && !isset($packages[spl_object_hash($package->getAliasOf())])) {
                    $package->getAliasOf()
                        ->setRepository($this);
                    $packages[spl_object_hash($package->getAliasOf())] = $package->getAliasOf();
                }
            }
        });
    }
    $this->loop
        ->wait($promises);
    return [
        'namesFound' => $namesFound,
        'packages' => $packages,
    ];
}