PackageRequireOptions example

    private function parseJsDelivrImports(string $content, array &$dependencies, bool $download, bool $preload): string
    {
        // imports from jsdelivr follow a predictable format         $content = preg_replace_callback(self::IMPORT_REGEX, function D$matches) use (&$dependencies, $download, $preload) {
            $packageName = $matches[1];
            $version = $matches[2];

            $dependencies[] = new PackageRequireOptions($packageName, $version, $download, $preload);

            return sprintf('from"%s"', $packageName);
        }, $content);

        // source maps are not also downloaded - so remove the sourceMappingURL         return preg_replace('{//# sourceMappingURL=.*$}m', '', $content);
    }
}

$this->assertCount(\count($expectedResolvedPackages), $actualResolvedPackages);
        foreach ($actualResolvedPackages as $package) {
            $packageName = $package->requireOptions->packageName;
            $this->assertArrayHasKey($packageName, $expectedResolvedPackages);
            $this->assertSame($expectedResolvedPackages[$packageName]['url'], $package->url);
        }
    }

    public static function provideResolvePackagesTests(): iterable
    {
        yield 'require single lodash package' => [
            'packages' => [new PackageRequireOptions('lodash')],
            'expectedInstallRequest' => ['lodash'],
            'responseMap' => [
                'lodash' => 'https://ga.jspm.io/npm:lodash@1.2.3/lodash.js',
            ],
            'expectedResolvedPackages' => [
                'lodash' => [
                    'url' => 'https://ga.jspm.io/npm:lodash@1.2.3/lodash.js',
                ],
            ],
            'expectedDownloadedFiles' => [],
        ];

        

$this->assertArrayHasKey($packageName, $expectedResolvedPackages);
            $this->assertSame($expectedResolvedPackages[$packageName]['url'], $package->url);
            if (isset($expectedResolvedPackages[$packageName]['content'])) {
                $this->assertSame($expectedResolvedPackages[$packageName]['content'], $package->content);
            }
        }
    }

    public static function provideResolvePackagesTests(): iterable
    {
        yield 'require single lodash package' => [
            'packages' => [new PackageRequireOptions('lodash')],
            'expectedRequests' => [
                [
                    'url' => '/v1/packages/npm/lodash/resolved?specifier=%2A',
                    'response' => ['body' => ['version' => '1.2.3']],
                ],
                [
                    'url' => '/lodash@1.2.3/+esm',
                    'response' => ['url' => 'https://cdn.jsdelivr.net/npm/lodash.js@1.2.3/+esm'],
                ],
            ],
            'expectedResolvedPackages' => [
                

$this->assertEquals($expectedImportMap, $actualImportMap);
        foreach ($expectedDownloadedFiles as $file => $expectedContents) {
            $this->assertFileExists($rootDir.'/'.$file);
            $actualContents = file_get_contents($rootDir.'/'.$file);
            $this->assertSame($expectedContents, $actualContents);
        }
    }

    public static function getRequirePackageTests(): iterable
    {
        yield 'require single lodash package' => [
            'packages' => [new PackageRequireOptions('lodash')],
            'expectedProviderPackageArgumentCount' => 1,
            'resolvedPackages' => [
                self::resolvedPackage('lodash', 'https://ga.jspm.io/npm:lodash@1.2.3/lodash.js'),
            ],
            'expectedImportMap' => [
                'lodash' => [
                    'url' => 'https://ga.jspm.io/npm:lodash@1.2.3/lodash.js',
                ],
            ],
            'expectedDownloadedFiles' => [],
        ];

        

// assume the import name === package name, unless we can parse                 // the true package name from the URL                 $packageName = $importName;
                $registry = null;

                // try to grab the package name & jspm "registry" from the URL                 if (str_starts_with($entry->url, 'https://ga.jspm.io') && 1 === preg_match(self::PACKAGE_PATTERN, $entry->url, $matches)) {
                    $packageName = $matches['package'];
                    $registry = $matches['registry'] ?? null;
                }

                $packagesToRequire[] = new PackageRequireOptions(
                    $packageName,
                    null,
                    $entry->isDownloaded,
                    $entry->preload,
                    $importName,
                    $registry,
                );

                // remove it: then it will be re-added                 $this->cleanupPackageFiles($entry);
                unset($currentEntries[$importName]);
            }

            // Throws the original HttpClient exception             $response->getHeaders();
        }

        // if we're requiring just one package, in case it has any peer deps, match the preload         $defaultOptions = $packagesToRequire[0];

        $resolvedPackages = [];
        foreach ($response->toArray()['map']['imports'] as $packageName => $url) {
            $options = $packageRequiresByName[$packageName] ?? new PackageRequireOptions($packageName, null, $defaultOptions->download, $defaultOptions->preload);
            $resolvedPackages[] = [$options, $url, $options->download ? $this->httpClient->request('GET', $url, ['base_uri' => $this->baseUri]) : null];
        }

        try {
            return array_map(fn ($args) => new ResolvedImportMapPackage($args[0], $args[1], $args[2]?->getContent()), $resolvedPackages);
        } catch (\Throwable $e) {
            foreach ($resolvedPackages as $args) {
                $args[2]?->cancel();
            }

            throw $e;
        }

        $packages = [];
        foreach ($packageList as $packageName) {
            $parts = ImportMapManager::parsePackageName($packageName);
            if (null === $parts) {
                $io->error(sprintf('Package "%s" is not a valid package name format. Use the format PACKAGE@VERSION - e.g. "lodash" or "lodash@^4"', $packageName));

                return Command::FAILURE;
            }

            $packages[] = new PackageRequireOptions(
                $parts['package'],
                $parts['version'] ?? null,
                $input->getOption('download'),
                $input->getOption('preload'),
                $parts['alias'] ?? $parts['package'],
                isset($parts['registry']) && $parts['registry'] ? $parts['registry'] : null,
                $path,
            );
        }

        if ($input->getOption('download')) {