angular-compat-matrix 0.0.0-stage → 0.2.0

package/dist/exec.js

@@ -0,0 +1,166 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const ANSI = /\u001b\[[0-9;?]*[A-Za-z]|\u001b\][^\u0007]*\u0007/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI, '');
+}
+/** Environment every child gets: no prompts, no analytics, no colour codes to strip later. */
+export function quietEnv(extra = {}) {
+    return {
+        ...process.env,
+        NG_CLI_ANALYTICS: 'false',
+        NG_DISABLE_VERSION_CHECK: '1',
+        NO_UPDATE_NOTIFIER: '1',
+        NPM_CONFIG_UPDATE_NOTIFIER: 'false',
+        NPM_CONFIG_FUND: 'false',
+        NPM_CONFIG_AUDIT: 'false',
+        FORCE_COLOR: '0',
+        ...extra,
+    };
+}
+/** Every child still running, so an interrupt can stop them all. */
+const running = new Set();
+/** Stops every running child and everything it started (npm, then the build it runs). */
+export function killAllChildren() {
+    for (const child of running)
+        killTree(child.pid);
+    running.clear();
+}
+let verboseEnabled = false;
+export function setVerbose(enabled) {
+    verboseEnabled = enabled;
+}
+export function isVerbose() {
+    return verboseEnabled;
+}
+export function exec(command, args, options) {
+    const started = Date.now();
+    if (verboseEnabled) {
+        const fullCmd = options.shell ? [command, ...args].join(' ') : `${command} ${args.join(' ')}`;
+        process.stderr.write(`[ng-matrix] > ${fullCmd}\n`);
+    }
+    return new Promise((resolve) => {
+        // On Linux and macOS each child leads its own process group, so killing the group stops
+        // its children too. Windows has taskkill /T for that.
+        const detached = process.platform !== 'win32';
+        const child = options.shell
+            ? spawn([command, ...args].join(' '), { cwd: options.cwd, env: options.env ?? quietEnv(), shell: true, detached })
+            : spawn(command, args, { cwd: options.cwd, env: options.env ?? quietEnv(), detached });
+        running.add(child);
+        let output = '';
+        let timedOut = false;
+        const append = (chunk) => (output += chunk.toString('utf8'));
+        child.stdout?.on('data', append);
+        child.stderr?.on('data', append);
+        const timer = options.timeoutMs
+            ? setTimeout(() => {
+                timedOut = true;
+                killTree(child.pid);
+            }, options.timeoutMs)
+            : undefined;
+        const finish = (code) => {
+            running.delete(child);
+            if (timer)
+                clearTimeout(timer);
+            resolve({ code, output: stripAnsi(output), durationMs: Date.now() - started, timedOut });
+        };
+        child.on('error', (error) => {
+            output += `\n${error.message}`;
+            finish(127);
+        });
+        child.on('close', (code) => finish(code ?? 1));
+    });
+}
+function killTree(pid) {
+    if (!pid)
+        return;
+    if (process.platform === 'win32') {
+        spawnSync('taskkill', ['/pid', String(pid), '/T', '/F']);
+    }
+    else {
+        try {
+            process.kill(-pid, 'SIGKILL');
+        }
+        catch {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // already gone
+            }
+        }
+    }
+}
+/**
+ * npm's own CLI script, so npm runs as `node npm-cli.js` without a shell
+ * (spawning `npm.cmd` on Windows needs one, and then every argument needs quoting).
+ */
+export function npmCli() {
+    const candidates = [
+        process.env.npm_execpath,
+        join(dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        join(dirname(process.execPath), '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    ];
+    for (const candidate of candidates) {
+        if (candidate && /npm-cli\.js$/.test(candidate) && existsSync(candidate))
+            return [process.execPath, candidate];
+    }
+    throw new Error("Couldn't find npm next to this Node. ng-matrix needs the npm that ships with Node.");
+}
+export function npm(args, options) {
+    const [node, cli] = npmCli();
+    return exec(node, [cli, ...args], options);
+}
+/** The first lines that look like errors, with a little context, for reports. */
+export function errorLines(output, max = 12) {
+    const lines = output.split(/\r?\n/).map((line) => line.trimEnd());
+    // Errors first; warnings (Angular prints NG8113 "not used" ones, say) only when there's nothing else.
+    const errors = /(\[ERROR\]|\berror TS\d+|\bERR_PNPM_|npm error|^\s*Error:|✘|✕|^\s*X |\berror NG\d{4}\b|ERESOLVE|unmet peer|invalid: )/i;
+    const anything = /(\[WARNING\]|\bNG\d{4}\b|\bwarn)/i;
+    for (const marker of [errors, anything]) {
+        const picked = [];
+        for (let i = 0; i < lines.length && picked.length < max; i++) {
+            if (!marker.test(lines[i]))
+                continue;
+            for (let j = i; j < Math.min(lines.length, i + 6) && picked.length < max; j++) {
+                const line = lines[j];
+                if (j > i && (errors.test(line) || anything.test(line)) && !marker.test(line))
+                    break;
+                if (line.trim() && !picked.includes(line))
+                    picked.push(line);
+            }
+            i += 5;
+        }
+        if (picked.length)
+            return picked;
+    }
+    return lines.filter((line) => line.trim()).slice(-max);
+}
+/** How long any one step (ng new, an install, a build, the tests) may take: --step-timeout. */
+let stepTimeoutMs = 20 * 60_000;
+export function setStepTimeout(ms) {
+    stepTimeoutMs = ms;
+}
+export function stepTimeout() {
+    return stepTimeoutMs;
+}
+/**
+ * Why a step failed when it's the machine's fault, not the package's: it timed out, the disk is
+ * full, or the network dropped. Such a version is reported as not checked (exit 2), not as failing.
+ */
+export function environmentProblem(result) {
+    if (result.timedOut)
+        return `timed out after ${formatMinutes(stepTimeoutMs)} (raise the limit with --step-timeout <minutes>)`;
+    if (/\bENOSPC\b|no space left on device|not enough space on the disk/i.test(result.output)) {
+        return 'the disk is full (ENOSPC). Free some space, or point TMPDIR/TEMP and NG_MATRIX_CACHE somewhere with room';
+    }
+    const network = /^.*\b(EAI_AGAIN|ENOTFOUND|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ERR_SOCKET_TIMEOUT|ERR_PNPM_META_FETCH_FAIL|socket hang up)\b.*$/im.exec(result.output);
+    if (network)
+        return `a network error: ${network[0].trim().slice(0, 200)}`;
+    return undefined;
+}
+function formatMinutes(ms) {
+    const minutes = ms / 60_000;
+    return minutes >= 1 ? `${Number(minutes.toFixed(1))} min` : `${Math.round(ms / 1000)} s`;
+}

package/dist/install.js

@@ -0,0 +1,140 @@
+import { copyFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import semver from 'semver';
+import { readJson, writeJson } from "./app.js";
+import { environmentProblem, errorLines, exec, npm, quietEnv, stepTimeout } from "./exec.js";
+import { npmInstall, pnpmBuildSettings, skippedByNpm, skippedByPnpm } from "./scripts.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);
+}
+/**
+ * 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 npmInstall(args, { cwd: request.appDir, timeoutMs: stepTimeout() }, request.allowScripts);
+    const skippedScripts = request.allowScripts ? [] : skippedByNpm(request.appDir);
+    if (result.code !== 0) {
+        return {
+            pass: false,
+            message: 'npm install failed.',
+            errorLines: errorLines(result.output),
+            fullOutput: result.output,
+            ignored: [],
+            environment: environmentProblem(result),
+            skippedScripts,
+        };
+    }
+    const ls = await npm(['ls', '--all'], { cwd: request.appDir });
+    const problems = parseNpmLs(ls.output);
+    return { ...judgeProblems(request, problems), skippedScripts };
+}
+/** 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, so a package whose install script isn't
+ * allowed is skipped rather than failing the install; only the toolchain's builds are allowed.
+ */
+async function installWithPnpm(request, deps) {
+    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(allowed, request.allowScripts));
+    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: stepTimeout() });
+    const ignored = Object.entries(allowed).map(([key, major]) => `${key} allowed at ${major}.x`);
+    const skippedScripts = request.allowScripts ? [] : skippedByPnpm(result.output);
+    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),
+            fullOutput: result.output,
+            ignored,
+            environment: environmentProblem(result),
+            skippedScripts,
+        };
+    }
+    return {
+        pass: true,
+        message: ignored.length ? `Installed; allowed the expected conflict: ${ignored.join('; ')}.` : 'Installed.',
+        errorLines: [],
+        ignored,
+        skippedScripts,
+    };
+}
+export function pnpmWorkspaceYaml(allowed, allowScripts = false) {
+    const lines = ['strictPeerDependencies: true', ...pnpmBuildSettings(allowScripts)];
+    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,200 @@
+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 { environmentProblem, 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(packFailure(source, result.output), 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('/', '-'));
+}
+/** What went wrong with `npm pack <spec>`, in words: most often the name or the version doesn't exist. */
+export function packFailure(spec, output) {
+    if (/\bE404\b|404 Not Found/.test(output))
+        return `There's no package ${spec.replace(/(.)@[^@]*$/, '$1')} on the npm registry.`;
+    if (/\bETARGET\b|No matching version/.test(output))
+        return `${spec} doesn't match any published version.`;
+    const why = environmentProblem({ output, timedOut: false });
+    if (why)
+        return `Couldn't download ${spec}: ${why}.`;
+    return `npm pack ${spec} failed.`;
+}
+export async function extract(tarball, into) {
+    mkdirSync(into, { recursive: true });
+    try {
+        await tar.x({ file: tarball, cwd: into, strict: true });
+    }
+    catch (error) {
+        throw new LibraryError(`${tarball} isn't a package tarball (.tgz): ${error.message}`);
+    }
+    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,13 @@
+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 const SCHEMA_VERSION = 1;
+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();
+}