angular-compat-matrix 0.0.0-stage → 0.1.0

package/dist/install.js

@@ -0,0 +1,131 @@
+import { copyFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import semver from 'semver';
+import { readJson, writeJson } from "./app.js";
+import { errorLines, exec, npm, quietEnv } from "./exec.js";
+import { ensureTool, PNPM_VERSION, pnpmEntry } from "./tools.js";
+export function addDependencies(appDir, deps, extra = {}) {
+    const path = join(appDir, 'package.json');
+    const manifest = readJson(path);
+    manifest.dependencies = { ...(manifest.dependencies ?? {}), ...deps };
+    Object.assign(manifest, extra);
+    writeJson(path, manifest);
+}
+export async function installLibrary(request) {
+    const tgz = basename(request.tarball);
+    copyFileSync(request.tarball, join(request.appDir, tgz));
+    const deps = { ...request.plan.installs, [request.libraryName]: `file:${tgz}` };
+    return request.pm === 'npm' ? installWithNpm(request, deps) : installWithPnpm(request, deps, tgz);
+}
+/**
+ * npm 11 fails on any peer conflict and can't ignore just one. So: install without peer
+ * resolution, with the peers added explicitly, then let `npm ls` report every invalid peer.
+ */
+async function installWithNpm(request, deps) {
+    addDependencies(request.appDir, deps);
+    const args = ['install', '--legacy-peer-deps', '--no-audit', '--no-fund'];
+    if (request.offline)
+        args.push('--offline');
+    const result = await npm(args, { cwd: request.appDir, timeoutMs: 15 * 60_000 });
+    if (result.code !== 0) {
+        return { pass: false, message: 'npm install failed.', errorLines: errorLines(result.output), ignored: [] };
+    }
+    const ls = await npm(['ls', '--all'], { cwd: request.appDir });
+    const problems = parseNpmLs(ls.output);
+    return judgeProblems(request, problems);
+}
+/** Reads `npm ls --all` text output: `@angular/core@21.2.25 deduped invalid: "^22.0.0" from node_modules/@angular/cdk`. */
+export function parseNpmLs(output) {
+    const problems = [];
+    for (const raw of output.split(/\r?\n/)) {
+        const line = raw.replace(/^[\s|`+\\-]+/, '').trim();
+        const invalid = /^(@?[^@\s]+)@(\S+)(?: deduped)? invalid: (.+)$/.exec(line);
+        if (invalid) {
+            for (const want of invalid[3].matchAll(/"([^"]+)" from (\S+?)(?:,|$)/g)) {
+                problems.push({ name: invalid[1], installed: invalid[2], wanted: want[1], by: want[2].replace(/^.*node_modules\//, ''), line });
+            }
+            continue;
+        }
+        const unmet = /UNMET (?:OPTIONAL )?(?:PEER )?DEPENDENCY (@?[^@\s]+)@(\S+)/.exec(line);
+        if (unmet && !/OPTIONAL/.test(line))
+            problems.push({ name: unmet[1], wanted: unmet[2], line });
+    }
+    return problems;
+}
+function judgeProblems(request, problems) {
+    // Only conflicts about the package under test and the peers installed for it count;
+    // anything else in the tree is the generated app's own business.
+    const ours = new Set([request.libraryName, ...Object.keys(request.plan.installs)]);
+    const ourPeers = new Set([...Object.keys(request.plan.installs), ...Object.keys(request.plan.checked)]);
+    const relevant = problems.filter((p) => (p.by ? ours.has(p.by) : ourPeers.has(p.name)));
+    const outside = request.plan.claimed === false;
+    const ignored = relevant.filter((p) => outside && p.name.startsWith('@angular/') && p.by === request.libraryName);
+    const failing = relevant.filter((p) => !ignored.includes(p));
+    const describe = (p) => `${p.by ?? '?'} wants ${p.name}@"${p.wanted}"${p.installed ? `, found ${p.installed}` : ', missing'}`;
+    if (failing.length) {
+        return {
+            pass: false,
+            message: `Peer conflict: ${describe(failing[0])}${failing.length > 1 ? ` (+${failing.length - 1} more)` : ''}.`,
+            errorLines: failing.map((p) => p.line),
+            ignored: ignored.map(describe),
+        };
+    }
+    return {
+        pass: true,
+        message: ignored.length ? `Installed; ignored the expected conflict: ${ignored.map(describe).join('; ')}.` : 'Installed.',
+        errorLines: [],
+        ignored: ignored.map(describe),
+    };
+}
+/**
+ * pnpm only warns about peers by default, so strictPeerDependencies is on, with allowedVersions
+ * for the one expected conflict. strictDepBuilds is off: otherwise pnpm 12 fails every install
+ * on Angular's own esbuild, lmdb and @parcel/watcher scripts. The library's own scripts may run.
+ */
+async function installWithPnpm(request, deps, tgz) {
+    addDependencies(request.appDir, deps, { packageManager: `pnpm@${PNPM_VERSION}` });
+    const allowed = {};
+    if (request.plan.claimed === false) {
+        for (const miss of request.plan.misses) {
+            const major = semver.valid(miss.version) ? String(semver.major(miss.version)) : String(request.angularMajor);
+            allowed[`${request.libraryName}>${miss.name}`] = major;
+        }
+    }
+    writeFileSync(join(request.appDir, 'pnpm-workspace.yaml'), pnpmWorkspaceYaml(request.libraryName, tgz, allowed));
+    const pnpm = await ensureTool(request.cacheDir, 'pnpm', PNPM_VERSION, request.offline);
+    const args = [pnpmEntry(pnpm), 'install', '--no-frozen-lockfile'];
+    if (request.offline)
+        args.push('--offline');
+    const result = await exec(process.execPath, args, { cwd: request.appDir, env: quietEnv(), timeoutMs: 15 * 60_000 });
+    const ignored = Object.entries(allowed).map(([key, major]) => `${key} allowed at ${major}.x`);
+    if (result.code !== 0) {
+        const peer = /ERR_PNPM_PEER_DEP_ISSUES|unmet peer|Issues with peer dependencies/i.test(result.output);
+        return {
+            pass: false,
+            message: peer ? 'Peer conflict (pnpm strict-peer-dependencies).' : 'pnpm install failed.',
+            errorLines: errorLines(result.output),
+            ignored,
+        };
+    }
+    return {
+        pass: true,
+        message: ignored.length ? `Installed; allowed the expected conflict: ${ignored.join('; ')}.` : 'Installed.',
+        errorLines: [],
+        ignored,
+    };
+}
+export function pnpmWorkspaceYaml(libraryName, tgz, allowed) {
+    const lines = [
+        'strictPeerDependencies: true',
+        'strictDepBuilds: false',
+        'allowBuilds:',
+        // pnpm keys a tarball dependency by its full spec; the bare name doesn't match it.
+        `  ${JSON.stringify(`${libraryName}@file:${tgz}`)}: true`,
+    ];
+    if (Object.keys(allowed).length) {
+        lines.push('peerDependencyRules:', '  allowedVersions:');
+        for (const [key, range] of Object.entries(allowed))
+            lines.push(`    ${JSON.stringify(key)}: ${JSON.stringify(range)}`);
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/library.js

@@ -0,0 +1,184 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, join, resolve } from 'node:path';
+import * as tar from 'tar';
+import { errorLines, exec, npm, quietEnv } from "./exec.js";
+export class LibraryError extends Error {
+    lines;
+    constructor(message, lines = []) {
+        super(message);
+        this.lines = lines;
+    }
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+/** `dest` from an ng-package.json (or a package.json `ngPackage` field): the same for the CLI, ng-packagr and Nx. */
+export function ngPackageDest(ngPackagePath) {
+    const config = basename(ngPackagePath) === 'package.json'
+        ? (readJson(ngPackagePath).ngPackage ?? {})
+        : readJson(ngPackagePath);
+    return resolve(dirname(ngPackagePath), config.dest ?? 'dist');
+}
+function resolveBin(cwd, pkg, bin) {
+    const require = createRequire(join(cwd, 'noop.js'));
+    let manifestPath;
+    try {
+        manifestPath = require.resolve(`${pkg}/package.json`);
+    }
+    catch {
+        throw new LibraryError(`${pkg} isn't installed in ${cwd}. Install the workspace's dependencies first.`);
+    }
+    const manifest = readJson(manifestPath);
+    const relativeBin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.[bin];
+    if (!relativeBin)
+        throw new LibraryError(`${pkg} has no "${bin}" command.`);
+    return join(dirname(manifestPath), relativeBin);
+}
+export function detectBuild(options) {
+    const { cwd } = options;
+    const shell = (command) => () => exec(command, [], { cwd, shell: true });
+    const angularJson = join(cwd, 'angular.json');
+    if (existsSync(angularJson)) {
+        const workspace = readJson(angularJson);
+        const libraries = Object.entries(workspace.projects).filter(([, p]) => p.projectType === 'library');
+        if (!libraries.length)
+            throw new LibraryError('angular.json has no library project.');
+        let name = options.project;
+        if (!name) {
+            if (libraries.length > 1) {
+                throw new LibraryError(`This workspace has ${libraries.length} libraries (${libraries.map(([n]) => n).join(', ')}). Pick one with --project.`);
+            }
+            name = libraries[0][0];
+        }
+        const project = workspace.projects[name];
+        if (!project || project.projectType !== 'library')
+            throw new LibraryError(`No library project named "${name}" in angular.json.`);
+        const ngPackage = project.architect?.build?.options?.project ?? join(project.root ?? '', 'ng-package.json');
+        const dest = ngPackageDest(resolve(cwd, ngPackage));
+        if (options.build)
+            return { kind: 'angular-cli', label: options.build, dest, run: shell(options.build) };
+        return {
+            kind: 'angular-cli',
+            label: `ng build ${name} --configuration production`,
+            dest,
+            run: () => exec(process.execPath, [resolveBin(cwd, '@angular/cli', 'ng'), 'build', name, '--configuration', 'production'], {
+                cwd,
+                env: quietEnv(),
+            }),
+        };
+    }
+    const ngPackage = ['ng-package.json', 'package.json'].map((f) => join(cwd, f)).find((path) => {
+        if (!existsSync(path))
+            return false;
+        return basename(path) === 'ng-package.json' || Boolean(readJson(path).ngPackage);
+    });
+    if (ngPackage) {
+        const dest = ngPackageDest(ngPackage);
+        if (options.build)
+            return { kind: 'ng-packagr', label: options.build, dest, run: shell(options.build) };
+        const manifest = existsSync(join(cwd, 'package.json')) ? readJson(join(cwd, 'package.json')) : undefined;
+        if (manifest?.scripts?.build) {
+            return { kind: 'ng-packagr', label: 'npm run build', dest, run: () => npm(['run', 'build'], { cwd }) };
+        }
+        return {
+            kind: 'ng-packagr',
+            label: 'ng-packagr -p ng-package.json',
+            dest,
+            run: () => exec(process.execPath, [resolveBin(cwd, 'ng-packagr', 'ng-packagr'), '-p', ngPackage], { cwd }),
+        };
+    }
+    if (existsSync(join(cwd, 'nx.json'))) {
+        throw new LibraryError('Nx workspaces are planned for v0.2. For now, run ng-matrix from the library folder (the one with ng-package.json) with --build "npx nx build <lib>".');
+    }
+    throw new LibraryError('No Angular library here: expected angular.json with a library project, or ng-package.json. Or pass --tarball / --package.');
+}
+/**
+ * Full compilation output must never be published: ng-packagr guards that with a `prepublishOnly`
+ * script, which `npm pack` doesn't run. So ng-matrix checks for it itself.
+ */
+export function fullCompilationEvidence(dir) {
+    const manifestPath = join(dir, 'package.json');
+    if (existsSync(manifestPath)) {
+        const guard = readJson(manifestPath).scripts?.prepublishOnly ?? '';
+        if (/full compilation mode/i.test(guard))
+            return 'its package.json has ng-packagr\'s "full compilation mode" prepublishOnly guard';
+    }
+    const define = /ɵɵdefine(Component|Directive|Pipe|NgModule)\(/;
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        for (const entry of readdirSync(current)) {
+            if (entry === 'node_modules')
+                continue;
+            const path = join(current, entry);
+            if (statSync(path).isDirectory())
+                stack.push(path);
+            else if (/\.m?js$/.test(entry)) {
+                const match = define.exec(readFileSync(path, 'utf8'));
+                if (match)
+                    return `${path.slice(dir.length + 1)} calls ɵɵdefine${match[1]}, which only full compilation emits`;
+            }
+        }
+    }
+    return undefined;
+}
+async function pack(source, into) {
+    const result = await npm(['pack', source, '--pack-destination', into, '--json', '--ignore-scripts'], { cwd: into });
+    if (result.code !== 0)
+        throw new LibraryError(`npm pack ${source} failed.`, errorLines(result.output));
+    const json = result.output.slice(result.output.indexOf('['));
+    const [info] = JSON.parse(json);
+    // Scoped packages: npm reports "@scope/name-1.0.0.tgz" but writes "scope-name-1.0.0.tgz".
+    return join(into, info.filename.replace(/^@/, '').replace('/', '-'));
+}
+export async function extract(tarball, into) {
+    mkdirSync(into, { recursive: true });
+    await tar.x({ file: tarball, cwd: into });
+    const dir = join(into, 'package');
+    if (!existsSync(join(dir, 'package.json')))
+        throw new LibraryError(`${tarball} has no package/package.json.`);
+    return dir;
+}
+export async function prepareLibrary(options, workDir, log) {
+    const packDir = join(workDir, 'pack');
+    mkdirSync(packDir, { recursive: true });
+    let tarball;
+    let source;
+    if (options.tarball) {
+        tarball = resolve(options.cwd, options.tarball);
+        if (!existsSync(tarball))
+            throw new LibraryError(`No tarball at ${tarball}.`);
+        source = `tarball ${tarball}`;
+    }
+    else if (options.packageSpec) {
+        log(`Downloading ${options.packageSpec}…`);
+        tarball = await pack(options.packageSpec, packDir);
+        source = `${options.packageSpec} from the registry`;
+    }
+    else {
+        const plan = detectBuild(options);
+        if (!options.skipBuild) {
+            log(`Building the library: ${plan.label}`);
+            const built = await plan.run();
+            if (built.code !== 0)
+                throw new LibraryError(`The library build failed (${plan.label}).`, errorLines(built.output));
+        }
+        if (!existsSync(join(plan.dest, 'package.json'))) {
+            throw new LibraryError(`No package.json in the build output ${plan.dest}. Is ng-package.json's "dest" right?`);
+        }
+        const full = fullCompilationEvidence(plan.dest);
+        if (full) {
+            throw new LibraryError(`Refusing to pack ${plan.dest}: it was built in full compilation mode (${full}). Libraries must be published in partial mode; build with the production configuration or set "compilationMode": "partial".`);
+        }
+        tarball = await pack(plan.dest, packDir);
+        source = `${plan.label}, then npm pack`;
+    }
+    const dir = await extract(tarball, join(packDir, 'contents'));
+    if (options.tarball || options.packageSpec) {
+        const full = fullCompilationEvidence(dir);
+        if (full)
+            throw new LibraryError(`This package was built in full compilation mode (${full}); Angular apps can't use it reliably.`);
+    }
+    return { manifest: readJson(join(dir, 'package.json')), tarball, dir, source };
+}

package/dist/model.js

@@ -0,0 +1,12 @@
+export const CHECKS = ['peer', 'install', 'partial', 'aot', 'strict', 'tests'];
+export const CHECK_LABELS = {
+    peer: 'peer range',
+    install: 'install',
+    partial: 'partial',
+    aot: 'AOT build',
+    strict: 'strict types',
+    tests: 'tests',
+};
+export function result(status, message = '', extra = {}) {
+    return { status, message, errorLines: [], durationMs: 0, ...extra };
+}

package/dist/partial.js

@@ -0,0 +1,90 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import semver from 'semver';
+const DECLARE = /ɵɵngDeclare(\w+)\(\s*\{/g;
+export function scanSource(source, file) {
+    const found = [];
+    for (const match of source.matchAll(DECLARE)) {
+        // The fields come first in every declaration, well within this window.
+        const body = source.slice(match.index + match[0].length, match.index + match[0].length + 800);
+        const minVersion = /minVersion:\s*["']([^"']+)["']/.exec(body)?.[1];
+        const version = /\bversion:\s*["']([^"']+)["']/.exec(body)?.[1];
+        const type = /\btype:\s*([\w$]+)/.exec(body)?.[1] ?? '?';
+        if (minVersion && version)
+            found.push({ kind: match[1], type, minVersion, version, file });
+    }
+    return found;
+}
+export function scanPackage(dir) {
+    const found = [];
+    const walk = (current) => {
+        for (const entry of readdirSync(current)) {
+            if (entry === 'node_modules')
+                continue;
+            const path = join(current, entry);
+            if (statSync(path).isDirectory())
+                walk(path);
+            else if (/\.(mjs|js|cjs)$/.test(entry))
+                found.push(...scanSource(readFileSync(path, 'utf8'), relative(dir, path)));
+        }
+    };
+    walk(dir);
+    return found;
+}
+export function summarize(declarations) {
+    let highest;
+    let compiledWith;
+    for (const declaration of declarations) {
+        const min = semver.coerce(declaration.minVersion);
+        if (min && (!highest || semver.gt(min, semver.coerce(highest.minVersion))))
+            highest = declaration;
+        // Angular's own source builds say 0.0.0-PLACEHOLDER; that tells us nothing.
+        if (semver.valid(declaration.version) && !declaration.version.startsWith('0.0.0')) {
+            if (!compiledWith || semver.gt(declaration.version, compiledWith))
+                compiledWith = declaration.version;
+        }
+    }
+    return { declarations: declarations.length, highest, compiledWith };
+}
+export function judgePartial(summary, angularVersion) {
+    const app = semver.coerce(angularVersion);
+    if (!summary.highest) {
+        return { pass: true, advisory: false, message: 'No Angular declarations in the package.' };
+    }
+    const { highest } = summary;
+    const where = `${highest.type} (ɵɵngDeclare${highest.kind}, ${highest.file})`;
+    if (semver.lt(app, semver.coerce(highest.minVersion))) {
+        return {
+            pass: false,
+            advisory: false,
+            message: `Needs Angular ${highest.minVersion} or later: highest minVersion ${highest.minVersion}, in ${where}.`,
+        };
+    }
+    const advisory = Boolean(summary.compiledWith && semver.major(summary.compiledWith) > app.major);
+    return {
+        pass: true,
+        advisory,
+        message: advisory
+            ? `Highest minVersion ${highest.minVersion} allows it, but the package was compiled with Angular ${summary.compiledWith} and minVersion has been too low before, so only the build can tell.`
+            : `Highest minVersion ${highest.minVersion}, in ${where}.`,
+    };
+}
+/** The `@angular/*` packages the published JavaScript imports (`@angular/common/http` counts as `@angular/common`). */
+export function angularImports(dir) {
+    const found = new Set();
+    const specifier = /(?:\bfrom|\bimport)\s*\(?\s*["'](@angular\/[\w.-]+)(?:\/[^"']*)?["']/g;
+    const walk = (current) => {
+        for (const entry of readdirSync(current)) {
+            if (entry === 'node_modules')
+                continue;
+            const path = join(current, entry);
+            if (statSync(path).isDirectory())
+                walk(path);
+            else if (/\.(mjs|js|cjs)$/.test(entry))
+                for (const match of readFileSync(path, 'utf8').matchAll(specifier))
+                    found.add(match[1]);
+        }
+    };
+    walk(dir);
+    return [...found].sort();
+}

package/dist/peers.js

@@ -0,0 +1,79 @@
+import semver from 'semver';
+import { newestSatisfying } from "./versions.js";
+/** Packages released in lockstep with `@angular/core`: same version number, always. */
+export const FRAMEWORK = new Set([
+    '@angular/animations',
+    '@angular/common',
+    '@angular/compiler',
+    '@angular/compiler-cli',
+    '@angular/core',
+    '@angular/elements',
+    '@angular/forms',
+    '@angular/language-service',
+    '@angular/localize',
+    '@angular/platform-browser',
+    '@angular/platform-browser-dynamic',
+    '@angular/platform-server',
+    '@angular/router',
+    '@angular/service-worker',
+    '@angular/upgrade',
+]);
+/** Peers a generated app already has at the right version, so they're never installed again. */
+const APP_PROVIDED = new Set(['rxjs', 'tslib', 'zone.js', 'typescript']);
+function isOptional(manifest, name) {
+    return Boolean(manifest.peerDependenciesMeta?.[name]?.optional);
+}
+/**
+ * The newest version of a non-framework peer (Angular Material, the CDK, a third-party package)
+ * that a real app on this Angular would use: one whose own `@angular/*` peers accept it,
+ * preferring versions the library's range allows.
+ */
+export function pickPeerVersion(packument, libraryRange, angularVersion) {
+    const pre = Boolean(semver.prerelease(angularVersion));
+    const candidates = Object.keys(packument.versions)
+        .filter((v) => semver.valid(v) && (pre || !semver.prerelease(v)))
+        .sort(semver.rcompare);
+    const acceptsAngular = (v) => {
+        const peers = packument.versions[v].peerDependencies ?? {};
+        const framework = Object.entries(peers).filter(([name]) => FRAMEWORK.has(name));
+        return framework.every(([, range]) => semver.satisfies(angularVersion, range, { includePrerelease: true }));
+    };
+    const inRange = (v) => semver.satisfies(v, libraryRange, { includePrerelease: true });
+    const hasFrameworkPeer = (v) => Object.keys(packument.versions[v].peerDependencies ?? {}).some((name) => FRAMEWORK.has(name));
+    // Packages that don't depend on Angular (say, a date library) just follow the library's range.
+    if (!candidates.some(hasFrameworkPeer))
+        return candidates.find(inRange) ?? newestSatisfying(packument, '*');
+    return (candidates.find((v) => acceptsAngular(v) && inRange(v)) ??
+        candidates.find(acceptsAngular) ??
+        candidates.find(inRange));
+}
+export async function planPeers(manifest, angularVersion, registry) {
+    const peers = manifest.peerDependencies ?? {};
+    const installs = {};
+    const checked = {};
+    const misses = [];
+    let angularPeers = 0;
+    for (const [name, range] of Object.entries(peers)) {
+        let version;
+        if (FRAMEWORK.has(name)) {
+            version = angularVersion;
+            installs[name] = angularVersion;
+        }
+        else if (!APP_PROVIDED.has(name)) {
+            version = pickPeerVersion(await registry.get(name), range, angularVersion);
+            if (version)
+                installs[name] = version;
+        }
+        // Optional peers are installed (the smoke app imports every entry point, and some entry point
+        // needs them, as angular-calendar's date-fns adapter needs date-fns) but claim nothing.
+        if (!name.startsWith('@angular/') || isOptional(manifest, name))
+            continue;
+        angularPeers++;
+        const against = version ?? 'none';
+        checked[name] = against;
+        if (!version || !semver.satisfies(version, range, { includePrerelease: true })) {
+            misses.push({ name, range, version: against });
+        }
+    }
+    return { claimed: angularPeers ? misses.length === 0 : null, misses, installs, checked };
+}

package/dist/registry.js

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const DAY = 24 * 60 * 60 * 1000;
+const FULL_DOCUMENT = new Set(['@angular/core']);
+export class Registry {
+    memory = new Map();
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get(name) {
+        let pending = this.memory.get(name);
+        if (!pending) {
+            pending = this.load(name);
+            this.memory.set(name, pending);
+        }
+        return pending;
+    }
+    async load(name) {
+        const file = `${encodeURIComponent(name)}.json`;
+        if (this.options.recordedDir) {
+            const path = join(this.options.recordedDir, file);
+            if (!existsSync(path))
+                throw new Error(`No recorded registry answer for ${name} (${path})`);
+            return JSON.parse(readFileSync(path, 'utf8'));
+        }
+        const dir = join(this.options.cacheDir, 'registry');
+        const path = join(dir, file);
+        const cached = existsSync(path)
+            ? JSON.parse(readFileSync(path, 'utf8'))
+            : undefined;
+        const maxAge = this.options.maxAgeMs ?? DAY;
+        if (cached && (this.options.offline || Date.now() - cached.fetchedAt < maxAge))
+            return cached.packument;
+        if (this.options.offline)
+            throw new Error(`--offline: ${name} isn't in the registry cache yet. Run once online first.`);
+        const base = (this.options.registryUrl ?? process.env.npm_config_registry ?? 'https://registry.npmjs.org/').replace(/\/?$/, '/');
+        const url = base + name.replace('/', '%2f');
+        // Only @angular/core's publish dates are needed (to tell which majors are supported); everything
+        // else comes from the abbreviated document, which is much smaller for packages with many versions.
+        const accept = FULL_DOCUMENT.has(name)
+            ? 'application/json'
+            : 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8';
+        let response;
+        try {
+            response = await fetch(url, { headers: { accept } });
+        }
+        catch (error) {
+            if (cached)
+                return cached.packument;
+            throw new Error(`Couldn't reach the npm registry for ${name}: ${error.message}`);
+        }
+        if (!response.ok) {
+            if (cached)
+                return cached.packument;
+            throw new Error(`The npm registry answered ${response.status} for ${name}`);
+        }
+        const packument = trim((await response.json()));
+        mkdirSync(dir, { recursive: true });
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify({ fetchedAt: Date.now(), packument }));
+        renameSync(tmp, path);
+        return packument;
+    }
+}
+export function trim(raw) {
+    const versions = {};
+    for (const [version, meta] of Object.entries(raw.versions ?? {})) {
+        const kept = { version };
+        if (meta.peerDependencies)
+            kept.peerDependencies = meta.peerDependencies;
+        if (meta.peerDependenciesMeta)
+            kept.peerDependenciesMeta = meta.peerDependenciesMeta;
+        if (meta.dependencies)
+            kept.dependencies = meta.dependencies;
+        if (meta.engines && typeof meta.engines === 'object')
+            kept.engines = meta.engines;
+        versions[version] = kept;
+    }
+    const time = {};
+    for (const version of Object.keys(versions))
+        if (raw.time?.[version])
+            time[version] = raw.time[version];
+    return { name: raw.name, 'dist-tags': raw['dist-tags'] ?? {}, versions, time };
+}