angular-compat-matrix 0.0.0-stage → 0.2.0

package/dist/run.js

@@ -0,0 +1,280 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { freemem, availableParallelism } from 'node:os';
+import { join, relative, sep } from 'node:path';
+import { configureBuild, generateApp, readJson, writeJson } from "./app.js";
+import { findUndeclaredImports, isDtsOnlyFailure, ngBuild } from "./build.js";
+import { installLibrary } from "./install.js";
+import { CHECKS, result } from "./model.js";
+import { judgePartial } from "./partial.js";
+import { planPeers } from "./peers.js";
+import { entryPoints, hasSignalWriteBrand, readPublicApi, renderSmoke, writeSmoke } from "./smoke.js";
+import { runLibraryTests, swapVersions } from "./tests.js";
+/** About what one Angular production build needs; versions beyond what memory allows wait their turn. */
+const MEMORY_PER_VERSION = 2.5 * 1024 ** 3;
+export function defaultConcurrency(versions) {
+    const byMemory = Math.floor(freemem() / MEMORY_PER_VERSION);
+    return Math.max(1, Math.min(versions, byMemory, availableParallelism()));
+}
+export async function runAll(ctx, majors, concurrency) {
+    const reports = new Array(majors.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < majors.length) {
+            const index = next++;
+            reports[index] = await checkVersion(ctx, majors[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, majors.length) }, worker));
+    return reports;
+}
+function installedAngular(appDir, fallback) {
+    try {
+        const require = createRequire(join(appDir, 'package.json'));
+        return JSON.parse(readFileSync(require.resolve('@angular/core/package.json'), 'utf8')).version;
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function checkVersion(ctx, angular) {
+    const started = Date.now();
+    const tag = `Angular ${angular.major}`;
+    const checks = Object.fromEntries(CHECKS.map((c) => [c, result('not-run')]));
+    if (!ctx.tests)
+        checks.tests = result('off', 'Not requested (--tests).');
+    const report = {
+        major: angular.major,
+        angularVersion: angular.version,
+        supported: angular.supported,
+        prerelease: angular.prerelease,
+        claimed: null,
+        peerMisses: [],
+        checks,
+        durationMs: 0,
+    };
+    const finish = () => {
+        report.durationMs = Date.now() - started;
+        ctx.progress?.done(angular.major);
+        ctx.log(`${tag}: done in ${Math.round(report.durationMs / 1000)} s`);
+        return report;
+    };
+    // A timeout, a full disk or a network error says nothing about the package: this version
+    // wasn't checked (exit 2), rather than failing a check.
+    const notChecked = (step, why, lines) => {
+        report.setupError = [`${step} on ${tag}: ${why}.`, ...lines].join('\n');
+        return finish();
+    };
+    // Peer range: reported, but never stops the other checks.
+    const plan = await planPeers(ctx.library.manifest, angular.version, ctx.registry);
+    report.claimed = plan.claimed;
+    report.peerMisses = plan.misses;
+    checks.peer =
+        plan.claimed === null
+            ? result('none', 'The package declares no @angular/* peer dependency.')
+            : plan.claimed
+                ? result('pass', `Claimed: ${Object.entries(plan.checked).map(([n, v]) => `${n}@${v}`).join(', ')}.`)
+                : result('fail', plan.misses.map((m) => `${m.name} "${m.range}" doesn't allow ${m.version}`).join('; ') + '.');
+    const versionDir = join(ctx.workDir, `angular-${angular.major}`);
+    mkdirSync(versionDir, { recursive: true });
+    let appDir;
+    try {
+        ctx.progress?.step(angular.major, ctx.consumer ? 'creating consumer app' : `ng new (CLI ${angular.cliVersion})`);
+        ctx.log(`${tag}: creating the app (${ctx.consumer ? 'your --consumer app' : `ng new, CLI ${angular.cliVersion}`})`);
+        appDir = ctx.consumer
+            ? await copyConsumer(ctx, angular, plan.installs, versionDir)
+            : await generateApp(angular, ctx.pm, versionDir, ctx.cacheDir, ctx.offline);
+        if (ctx.keep)
+            report.appDir = appDir;
+    }
+    catch (error) {
+        report.setupError = error.message;
+        if (!ctx.keep)
+            rmSync(versionDir, { recursive: true, force: true, maxRetries: 3 });
+        return finish();
+    }
+    try {
+        ctx.progress?.step(angular.major, `installing with ${ctx.pm}`);
+        ctx.log(`${tag}: installing ${ctx.library.manifest.name} with ${ctx.pm}`);
+        const installStarted = Date.now();
+        const installed = await installLibrary({
+            appDir,
+            pm: ctx.pm,
+            libraryName: ctx.library.manifest.name,
+            tarball: ctx.library.tarball,
+            plan,
+            angularMajor: angular.major,
+            cacheDir: ctx.cacheDir,
+            offline: ctx.offline,
+            allowScripts: ctx.allowScripts,
+        });
+        if (installed.skippedScripts.length)
+            report.skippedInstallScripts = installed.skippedScripts;
+        if (installed.environment)
+            return notChecked('The install', installed.environment, installed.errorLines);
+        checks.install = result(installed.pass ? 'pass' : 'fail', installed.message, {
+            errorLines: installed.errorLines,
+            fullOutput: installed.fullOutput,
+            hint: installed.pass ? undefined : installed.errorLines[0],
+            durationMs: Date.now() - installStarted,
+        });
+        if (!installed.pass)
+            return finish();
+        const actual = installedAngular(appDir, angular.version);
+        report.angularVersion = actual;
+        const partial = judgePartial(ctx.summary, actual);
+        checks.partial = result(partial.pass ? 'pass' : 'fail', partial.message, {
+            advisory: partial.advisory,
+            hint: partial.pass ? undefined : 'Build the library with the oldest Angular you support, or take this version out of the peer range.',
+        });
+        if (!partial.pass)
+            return finish();
+        let files;
+        let api;
+        if (!ctx.consumer) {
+            try {
+                api = readPublicApi(appDir, entryPoints(ctx.library.manifest));
+                writeSmoke(appDir, renderSmoke(api, { signalWriteBrand: hasSignalWriteBrand(appDir) }));
+                files = ['src/ngm-main.ts'];
+            }
+            catch (error) {
+                checks.aot = result('fail', `Couldn't generate the smoke app from the package's typings: ${error.message}`, {
+                    hint: 'If the typings are fine, give ng-matrix an example app with --consumer.',
+                });
+                return finish();
+            }
+        }
+        const project = configureBuild(appDir, files?.[0]);
+        ctx.progress?.step(angular.major, 'AOT build');
+        ctx.log(`${tag}: AOT build`);
+        let aot = await ngBuild(appDir, project.tsConfig, { strictTemplates: false, skipLibCheck: true }, files);
+        if (aot.environment)
+            return notChecked('The AOT build', aot.environment, aot.errorLines);
+        const omittedList = [];
+        while (!aot.pass && !ctx.consumer && api) {
+            const undeclared = findUndeclaredImports(aot.errorLines, ctx.library.manifest, api.entries);
+            if (!undeclared.length)
+                break;
+            const mainName = ctx.library.manifest.name;
+            const isMain = (entry) => entry === mainName || entry === '.';
+            const mainUndeclared = undeclared.find((u) => isMain(u.entry));
+            const omittedSet = new Set(undeclared.map((u) => u.entry));
+            const remainingEntries = api.entries.filter((e) => !omittedSet.has(e));
+            if (mainUndeclared || remainingEntries.length === 0) {
+                const item = mainUndeclared ?? undeclared[0];
+                const reason = `${item.entry} imports ${item.missingPackage}, which isn't declared in dependencies or peers. Every user of ${item.entry} needs ${item.missingPackage} installed.`;
+                checks.aot = result('fail', reason, {
+                    errorLines: aot.errorLines,
+                    fullOutput: aot.fullOutput,
+                    hint: reason,
+                    durationMs: aot.durationMs,
+                });
+                return finish();
+            }
+            omittedList.push(...undeclared);
+            api.entries = remainingEntries;
+            api.declarables = api.declarables.filter((d) => !d.entry || !omittedSet.has(d.entry));
+            api.pipes = api.pipes.filter((p) => !p.entry || !omittedSet.has(p.entry));
+            api.modules = api.modules.filter((m) => !omittedSet.has(m.entry));
+            api.services = api.services.filter((s) => !omittedSet.has(s.entry));
+            writeSmoke(appDir, renderSmoke(api, { signalWriteBrand: hasSignalWriteBrand(appDir) }));
+            ctx.log(`${tag}: re-running AOT build without omitted entry points: ${[...omittedSet].join(', ')}`);
+            aot = await ngBuild(appDir, project.tsConfig, { strictTemplates: false, skipLibCheck: true }, files);
+            if (aot.environment)
+                return notChecked('The AOT build', aot.environment, aot.errorLines);
+        }
+        if (omittedList.length) {
+            report.omittedEntryPoints = omittedList;
+        }
+        checks.aot = result(aot.pass ? 'pass' : 'fail', aot.pass ? 'Production build succeeded.' : 'Production build failed.', {
+            errorLines: aot.errorLines,
+            fullOutput: aot.fullOutput,
+            hint: aot.hint ?? aot.errorLines[0],
+            durationMs: aot.durationMs,
+        });
+        if (!aot.pass)
+            return finish();
+        ctx.progress?.step(angular.major, 'strict build');
+        ctx.log(`${tag}: strict build`);
+        const strict = await ngBuild(appDir, project.tsConfig, { strictTemplates: true, skipLibCheck: false }, files);
+        if (strict.environment)
+            return notChecked('The strict build', strict.environment, strict.errorLines);
+        const dtsOnly = !strict.pass && isDtsOnlyFailure(strict.errorLines);
+        if (dtsOnly) {
+            report.dtsErrors = true;
+        }
+        const dtsHint = strict.hint ?? (dtsOnly ? 'library typings have errors with skipLibCheck: false' : undefined);
+        checks.strict = result(strict.pass || dtsOnly ? 'pass' : 'fail', strict.pass
+            ? 'Builds with strictTemplates: true and skipLibCheck: false.'
+            : dtsOnly
+                ? 'Builds with strictTemplates: true; library typings have errors with skipLibCheck: false.'
+                : (dtsHint ?? strict.errorLines[0] ?? 'Fails with strictTemplates: true and skipLibCheck: false.'), {
+            errorLines: strict.errorLines,
+            fullOutput: strict.fullOutput,
+            hint: dtsHint ?? strict.errorLines[0],
+            durationMs: strict.durationMs,
+        });
+        if (checks.strict.status === 'fail')
+            return finish();
+        if (ctx.tests) {
+            if (!ctx.workspace) {
+                checks.tests = result('off', 'No workspace to test: the package came from --tarball or --package.');
+            }
+            else {
+                ctx.progress?.step(angular.major, 'library tests');
+                ctx.log(`${tag}: library tests`);
+                const tests = await runLibraryTests({
+                    workspace: ctx.workspace,
+                    into: join(versionDir, 'tests'),
+                    angular,
+                    peerVersions: plan.installs,
+                    pm: ctx.pm,
+                    command: ctx.testCommand,
+                    registry: ctx.registry,
+                    cacheDir: ctx.cacheDir,
+                    offline: ctx.offline,
+                    allowScripts: ctx.allowScripts,
+                });
+                if (tests.environment)
+                    return notChecked('The library tests', tests.environment, tests.errorLines);
+                checks.tests = result(tests.pass ? 'pass' : 'fail', tests.message, {
+                    errorLines: tests.errorLines,
+                    fullOutput: tests.fullOutput,
+                    hint: tests.pass ? undefined : tests.errorLines[0],
+                    durationMs: tests.durationMs,
+                });
+            }
+        }
+        return finish();
+    }
+    finally {
+        if (!ctx.keep)
+            rmSync(versionDir, { recursive: true, force: true, maxRetries: 3 });
+    }
+}
+/** Copies the author's example app and moves its Angular dependencies to this version. */
+async function copyConsumer(ctx, angular, peerVersions, versionDir) {
+    const source = ctx.consumer;
+    if (!existsSync(join(source, 'angular.json')))
+        throw new Error(`--consumer ${source} has no angular.json.`);
+    const appDir = join(versionDir, 'app');
+    const skip = new Set(['node_modules', '.angular', 'dist', '.git']);
+    cpSync(source, appDir, {
+        recursive: true,
+        filter: (path) => !relative(source, path).split(sep).some((part) => skip.has(part)),
+    });
+    for (const lock of ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'])
+        rmSync(join(appDir, lock), { force: true });
+    const manifestPath = join(appDir, 'package.json');
+    const manifest = readJson(manifestPath);
+    const request = { angular, peerVersions };
+    if (manifest.dependencies)
+        manifest.dependencies = swapVersions(manifest.dependencies, request);
+    if (manifest.devDependencies)
+        manifest.devDependencies = swapVersions(manifest.devDependencies, request);
+    // The package under test comes from the tarball, not from wherever the example points.
+    delete manifest.dependencies?.[ctx.library.manifest.name];
+    delete manifest.devDependencies?.[ctx.library.manifest.name];
+    writeJson(manifestPath, manifest);
+    return appDir;
+}

package/dist/scripts.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { npm } from "./exec.js";
+/*
+ * Install scripts run arbitrary code on the machine. By default ng-matrix runs only the ones the
+ * Angular toolchain itself needs: every package with an install script in a fresh Angular 17 to 22
+ * app is on this list. The package under test and its dependencies run none, unless --allow-scripts.
+ */
+export const TOOLCHAIN_BUILDS = ['@parcel/watcher', 'esbuild', 'lmdb', 'msgpackr-extract'];
+/**
+ * In the toolchain's tree with an install script that isn't needed, so it stays off and isn't
+ * reported: fsevents (macOS only) ships a prebuilt binary; its script would rebuild it with node-gyp.
+ */
+const TOOLCHAIN_UNNEEDED = ['fsevents'];
+export const ALLOW_SCRIPTS_WARNING = '--allow-scripts: install scripts of the package under test and all of its dependencies will run on this machine.';
+/**
+ * `npm install` with scripts off, then `npm rebuild` of just the toolchain packages: npm has no
+ * allow-list that works on both npm 10 and 11, but this does.
+ */
+export async function npmInstall(args, options, allowScripts) {
+    if (allowScripts)
+        return npm(args, options);
+    const installed = await npm([...args, '--ignore-scripts'], options);
+    if (installed.code !== 0)
+        return installed;
+    const present = TOOLCHAIN_BUILDS.filter((name) => existsSync(join(options.cwd, 'node_modules', ...name.split('/'), 'package.json')));
+    if (!present.length)
+        return installed;
+    const rebuilt = await npm(['rebuild', ...present], options);
+    return {
+        code: rebuilt.code,
+        output: `${installed.output}\n${rebuilt.output}`,
+        durationMs: installed.durationMs + rebuilt.durationMs,
+        timedOut: rebuilt.timedOut,
+    };
+}
+/** pnpm-workspace.yaml lines: builds allowed for the toolchain only, or for everything. */
+export function pnpmBuildSettings(allowScripts) {
+    if (allowScripts)
+        return ['strictDepBuilds: false', 'dangerouslyAllowAllBuilds: true'];
+    return ['strictDepBuilds: false', 'allowBuilds:', ...TOOLCHAIN_BUILDS.map((name) => `  ${JSON.stringify(name)}: true`)];
+}
+/** `name@version` of every installed package whose install script npm didn't run: its lockfile marks them. */
+export function skippedByNpm(appDir) {
+    let lock;
+    try {
+        lock = JSON.parse(readFileSync(join(appDir, 'package-lock.json'), 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const skipped = new Set();
+    for (const [path, entry] of Object.entries(lock.packages ?? {})) {
+        if (!entry.hasInstallScript || !path.includes('node_modules/'))
+            continue;
+        const name = path.slice(path.lastIndexOf('node_modules/') + 'node_modules/'.length);
+        if (TOOLCHAIN_BUILDS.includes(name) || TOOLCHAIN_UNNEEDED.includes(name))
+            continue;
+        // The lockfile lists every platform's optional packages; only what's on disk counts.
+        if (!existsSync(join(appDir, path, 'package.json')))
+            continue;
+        skipped.add(entry.version ? `${name}@${entry.version}` : name);
+    }
+    return [...skipped].sort();
+}
+/** pnpm says so itself: `Ignored build scripts: core-js@3.46.0, sharp@0.34.1.` */
+export function skippedByPnpm(output) {
+    const line = /Ignored build scripts:\s*(.+?)\.?\s*$/m.exec(output);
+    if (!line)
+        return [];
+    const names = line[1].split(/,\s*/).map((s) => s.trim()).filter(Boolean);
+    return [...new Set(names.filter((spec) => !TOOLCHAIN_UNNEEDED.includes(spec.replace(/(.)@[^@]*$/, '$1'))))].sort();
+}