angular-compat-matrix 0.0.0-stage → 0.2.0

package/dist/smoke.js

@@ -0,0 +1,526 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+/** Import paths of every entry point the package's `exports` map declares. */
+export function entryPoints(manifest) {
+    const exportsMap = manifest.exports;
+    if (!exportsMap || typeof exportsMap !== 'object')
+        return [manifest.name];
+    const entries = [];
+    for (const [key, value] of Object.entries(exportsMap)) {
+        if (!key.startsWith('.') || key.includes('*') || key === './package.json')
+            continue;
+        if (/\.(css|scss|json)$/.test(key))
+            continue;
+        if (!hasTypes(value))
+            continue;
+        entries.push(key === '.' ? manifest.name : `${manifest.name}/${key.slice(2)}`);
+    }
+    return entries.length ? entries : [manifest.name];
+}
+function hasTypes(value) {
+    if (typeof value === 'string')
+        return value.endsWith('.d.ts');
+    if (!value || typeof value !== 'object')
+        return false;
+    return Object.entries(value).some(([k, v]) => k === 'types' || k === 'typings' || hasTypes(v));
+}
+/** Reads the package's public API with the TypeScript the app itself installed. */
+export function readPublicApi(appDir, entries) {
+    const require = createRequire(join(appDir, 'package.json'));
+    const ts = require('typescript');
+    const probe = join(appDir, 'src', '__ngm_probe.ts');
+    writeFileSync(probe, entries.map((e, i) => `import * as e${i} from ${JSON.stringify(e)};\nvoid e${i};`).join('\n'));
+    try {
+        const program = ts.createProgram([probe], {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            strict: true,
+            skipLibCheck: true,
+            noEmit: true,
+            types: [],
+        });
+        return new ApiReader(ts, program).read(program.getSourceFile(probe), entries);
+    }
+    finally {
+        rmSync(probe, { force: true });
+    }
+}
+class ApiReader {
+    ts;
+    checker;
+    byNode = new Map();
+    api = { entries: [], declarables: [], pipes: [], modules: [], services: [] };
+    nextId = 0;
+    constructor(ts, program) {
+        this.ts = ts;
+        this.checker = program.getTypeChecker();
+    }
+    read(probe, entries) {
+        const ts = this.ts;
+        const pendingModules = [];
+        const imports = probe.statements.filter(ts.isImportDeclaration);
+        imports.forEach((statement, index) => {
+            const entry = entries[index];
+            const moduleSymbol = this.checker.getSymbolAtLocation(statement.moduleSpecifier);
+            if (!moduleSymbol)
+                throw new Error(`TypeScript can't resolve ${entry} in the smoke app.`);
+            this.api.entries.push(entry);
+            for (const exported of this.checker.getExportsOfModule(moduleSymbol)) {
+                const target = exported.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(exported) : exported;
+                const node = target.declarations?.find(ts.isClassDeclaration);
+                if (!node)
+                    continue;
+                const kind = this.classify(node, exported.name, entry);
+                if (kind?.module)
+                    pendingModules.push({ node, info: kind.module });
+            }
+        });
+        for (const { node, info } of pendingModules)
+            info.exports = this.moduleExports(node, new Set());
+        return this.api;
+    }
+    staticType(node, name) {
+        const ts = this.ts;
+        for (const member of node.members) {
+            if (!ts.isPropertyDeclaration(member) || !member.type)
+                continue;
+            if (!member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword))
+                continue;
+            if (member.name.getText() !== name)
+                continue;
+            if (ts.isTypeReferenceNode(member.type))
+                return member.type;
+        }
+        return undefined;
+    }
+    classify(node, exportName, entry) {
+        const known = this.byNode.get(node);
+        if (known) {
+            this.setExportName(known, exportName, entry);
+            return undefined;
+        }
+        const cmp = this.staticType(node, 'ɵcmp');
+        const dir = this.staticType(node, 'ɵdir');
+        const pipe = this.staticType(node, 'ɵpipe');
+        const mod = this.staticType(node, 'ɵmod');
+        const prov = this.staticType(node, 'ɵprov');
+        const id = `d${this.nextId++}`;
+        const className = node.name?.text ?? 'Anonymous';
+        if (cmp || dir) {
+            const args = (cmp ?? dir).typeArguments ?? [];
+            this.byNode.set(node, id);
+            this.api.declarables.push({
+                id,
+                kind: cmp ? 'component' : 'directive',
+                className,
+                exportName,
+                entry,
+                selector: this.literal(args[1]),
+                standalone: this.literal(args[7]) === 'true',
+                inputs: this.inputs(node, args[3]),
+                typeParams: node.typeParameters?.length ?? 0,
+            });
+            return {};
+        }
+        if (pipe) {
+            const args = pipe.typeArguments ?? [];
+            this.byNode.set(node, id);
+            this.api.pipes.push({
+                id,
+                className,
+                exportName,
+                entry,
+                pipeName: this.literal(args[1]) ?? '',
+                standalone: this.literal(args[2]) === 'true',
+                extraArgs: this.pipeExtraArgs(node),
+            });
+            return {};
+        }
+        if (mod) {
+            this.byNode.set(node, id);
+            if (!exportName || !entry)
+                return {};
+            const info = { id, exportName, entry, exports: [] };
+            this.api.modules.push(info);
+            return { module: info };
+        }
+        if (prov && exportName && entry) {
+            this.byNode.set(node, id);
+            this.api.services.push({ exportName, entry, typeParams: node.typeParameters?.length ?? 0 });
+        }
+        return undefined;
+    }
+    setExportName(id, exportName, entry) {
+        if (!exportName || !entry)
+            return;
+        const item = this.api.declarables.find((d) => d.id === id) ?? this.api.pipes.find((p) => p.id === id);
+        if (item && !item.exportName) {
+            item.exportName = exportName;
+            item.entry = entry;
+        }
+    }
+    /** What an NgModule exports: `static ɵmod: ɵɵNgModuleDeclaration<M, Declarations, Imports, Exports>`. */
+    moduleExports(node, seen) {
+        const ts = this.ts;
+        if (seen.has(node))
+            return [];
+        seen.add(node);
+        const exportsArg = this.staticType(node, 'ɵmod')?.typeArguments?.[3];
+        if (!exportsArg || !ts.isTupleTypeNode(exportsArg))
+            return [];
+        const ids = [];
+        for (const element of exportsArg.elements) {
+            if (!ts.isTypeQueryNode(element))
+                continue;
+            let symbol = this.checker.getSymbolAtLocation(element.exprName);
+            if (symbol && symbol.flags & ts.SymbolFlags.Alias)
+                symbol = this.checker.getAliasedSymbol(symbol);
+            const target = symbol?.declarations?.find(ts.isClassDeclaration);
+            if (!target)
+                continue;
+            if (this.staticType(target, 'ɵmod')) {
+                if (!this.byNode.has(target))
+                    this.classify(target, undefined, undefined);
+                ids.push(...this.moduleExports(target, seen));
+                continue;
+            }
+            if (!this.byNode.has(target))
+                this.classify(target, undefined, undefined);
+            const id = this.byNode.get(target);
+            if (id)
+                ids.push(id);
+        }
+        return ids;
+    }
+    literal(node) {
+        const ts = this.ts;
+        if (!node)
+            return undefined;
+        if (ts.isLiteralTypeNode(node)) {
+            const literal = node.literal;
+            if (ts.isStringLiteral(literal))
+                return literal.text;
+            if (literal.kind === ts.SyntaxKind.TrueKeyword)
+                return 'true';
+            if (literal.kind === ts.SyntaxKind.FalseKeyword)
+                return 'false';
+        }
+        return undefined;
+    }
+    /** Inputs map: `{ prop: "alias" }` before Angular 16, `{ prop: { alias; required; isSignal } }` since. */
+    inputs(node, map) {
+        const ts = this.ts;
+        if (!map || !ts.isTypeLiteralNode(map))
+            return [];
+        const inputs = [];
+        for (const member of map.members) {
+            if (!ts.isPropertySignature(member) || !member.type)
+                continue;
+            const property = ts.isStringLiteral(member.name) || ts.isIdentifier(member.name) ? member.name.text : member.name.getText();
+            let alias = property;
+            let required = false;
+            if (ts.isLiteralTypeNode(member.type)) {
+                alias = this.literal(member.type) ?? property;
+            }
+            else if (ts.isTypeLiteralNode(member.type)) {
+                for (const field of member.type.members) {
+                    if (!ts.isPropertySignature(field) || !field.type)
+                        continue;
+                    const key = ts.isStringLiteral(field.name) || ts.isIdentifier(field.name) ? field.name.text : '';
+                    if (key === 'alias')
+                        alias = this.literal(field.type) ?? property;
+                    if (key === 'required')
+                        required = this.literal(field.type) === 'true';
+                }
+            }
+            inputs.push({ property, alias, required, accessible: this.isPublicMember(node, property), bare: this.usedBare(node, property) });
+        }
+        return inputs;
+    }
+    /**
+     * Whether users write this input as a bare attribute (`<div myFlag>`): it takes a string,
+     * accepts string/boolean (e.g. booleanAttribute transform), or anything.
+     * If an input accepts strictly boolean (without accepting string or empty string), it must be bound
+     * with `[prop]="..."` because a bare attribute passes string `""`, causing TS2322 in strict templates.
+     */
+    usedBare(node, property) {
+        const ts = this.ts;
+        const write = this.inputWriteType(node, property);
+        if (!write)
+            return false;
+        const parts = write.isUnion() ? write.types : [write];
+        // Accepts string, any, unknown, or empty string literal "" (from booleanAttribute or union)
+        const stringFlags = ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.String;
+        return parts.some((part) => (part.flags & stringFlags) !== 0 || (part.isStringLiteral() && part.value === ''));
+    }
+    /** The type a binding to the input must have: a signal input's write type, `ngAcceptInputType_*`, or the property's type. */
+    inputWriteType(node, property) {
+        const ts = this.ts;
+        if (!node.name)
+            return undefined;
+        const classSymbol = this.checker.getSymbolAtLocation(node.name);
+        if (!classSymbol)
+            return undefined;
+        const accept = this.checker.getTypeOfSymbolAtLocation(classSymbol, node).getProperty(`ngAcceptInputType_${property}`);
+        if (accept)
+            return this.checker.getTypeOfSymbolAtLocation(accept, node);
+        const setter = this.setter(node, property);
+        if (setter?.parameters[0])
+            return this.checker.getTypeAtLocation(setter.parameters[0]);
+        const member = this.checker.getDeclaredTypeOfSymbol(classSymbol).getProperty(property);
+        if (!member)
+            return undefined;
+        const type = this.checker.getTypeOfSymbolAtLocation(member, node);
+        const name = type.getSymbol()?.getName() ?? type.aliasSymbol?.getName();
+        const isReference = (type.flags & ts.TypeFlags.Object) !== 0 && (type.objectFlags & ts.ObjectFlags.Reference) !== 0;
+        const args = isReference ? this.checker.getTypeArguments(type) : (type.aliasTypeArguments ?? []);
+        if (name === 'InputSignalWithTransform')
+            return args[1];
+        if (name === 'InputSignal' || name === 'ModelSignal')
+            return args[0];
+        return type;
+    }
+    /** An input written through a setter, whose type can differ from what the getter returns. */
+    setter(node, name) {
+        const ts = this.ts;
+        return node.members.find((m) => ts.isSetAccessorDeclaration(m) && (ts.isIdentifier(m.name) || ts.isStringLiteral(m.name)) && m.name.text === name);
+    }
+    isPublicMember(node, name) {
+        const ts = this.ts;
+        // `Class['prop']` is the getter's type; a setter's type can't be named, so those get `any`.
+        if (this.setter(node, name))
+            return false;
+        const member = node.members.find((m) => m.name && (ts.isIdentifier(m.name) || ts.isStringLiteral(m.name)) && m.name.text === name);
+        if (!member)
+            return false; // inherited or accessor-only: don't guess its type
+        const modifiers = ts.canHaveModifiers(member) ? (ts.getModifiers(member) ?? []) : [];
+        return !modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword);
+    }
+    pipeExtraArgs(node) {
+        const ts = this.ts;
+        const transforms = node.members.filter((m) => ts.isMethodDeclaration(m) && m.name.getText() === 'transform');
+        if (!transforms.length)
+            return 0;
+        const required = transforms.map((method) => method.parameters.filter((p) => !p.questionToken && !p.initializer && !p.dotDotDotToken).length);
+        return Math.max(0, Math.min(...required) - 1);
+    }
+}
+/** The first usable alternative of a selector like `button[mat-button], a[mat-button]`. */
+export function parseSelector(selector) {
+    for (const raw of splitTopLevel(selector)) {
+        const part = raw.replace(/:not\([^)]*\)/g, '').trim();
+        if (!part)
+            continue;
+        const tag = /^[a-zA-Z][\w-]*/.exec(part)?.[0];
+        const attributes = [...part.matchAll(/\[([^\]=~|^$*\s]+)\s*(?:[~|^$*]?=\s*["']?([^"'\]]*)["']?)?\]/g)].map((m) => ({
+            name: m[1],
+            value: m[2],
+        }));
+        const classes = [...part.replace(/\[[^\]]*\]/g, '').matchAll(/\.([\w-]+)/g)].map((m) => m[1]);
+        if (!tag && !attributes.length && !classes.length)
+            continue;
+        return { tag, attributes, classes };
+    }
+    return undefined;
+}
+function splitTopLevel(selector) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const char of selector) {
+        if (char === '(' || char === '[')
+            depth++;
+        if (char === ')' || char === ']')
+            depth--;
+        if (char === ',' && depth === 0) {
+            parts.push(current);
+            current = '';
+        }
+        else
+            current += char;
+    }
+    parts.push(current);
+    return parts;
+}
+const VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr']);
+export function renderSmoke(api, options) {
+    const names = new Map(); // `${entry}\u0000${export}` -> local identifier
+    const used = new Set(['Component', 'CUSTOM_ELEMENTS_SCHEMA', 'inject', 'NgmSmoke', 'NgmWrite']);
+    const local = (entry, exportName) => {
+        const key = `${entry}\u0000${exportName}`;
+        let name = names.get(key);
+        if (!name) {
+            name = exportName;
+            for (let n = 2; used.has(name); n++)
+                name = `${exportName}_${n}`;
+            used.add(name);
+            names.set(key, name);
+        }
+        return name;
+    };
+    const uses = [];
+    const counts = { components: 0, directives: 0, pipes: 0, modules: 0, services: 0 };
+    let field = 0;
+    const element = (declarable, fields) => {
+        const selector = declarable.selector ? parseSelector(declarable.selector) : undefined;
+        if (!selector)
+            return undefined;
+        const selectorAttributes = new Set(selector.attributes.map((a) => a.name));
+        // Required inputs get a value; so does a selector attribute that is a number or object input,
+        // since users bind those rather than writing them bare.
+        const bound = declarable.inputs.filter((i) => i.required || (selectorAttributes.has(i.alias) && !i.bare));
+        const boundAliases = new Set(bound.map((i) => i.alias));
+        const attrs = [];
+        for (const attribute of selector.attributes) {
+            if (boundAliases.has(attribute.name))
+                continue;
+            attrs.push(attribute.value === undefined ? attribute.name : `${attribute.name}="${escapeAttr(attribute.value)}"`);
+        }
+        if (selector.classes.length)
+            attrs.push(`class="${selector.classes.join(' ')}"`);
+        for (const input of bound) {
+            const name = `v${field++}`;
+            const type = declarable.exportName && declarable.entry && input.accessible
+                ? writeType(local(declarable.entry, declarable.exportName), declarable.typeParams, input.property)
+                : 'any';
+            fields.push(`  protected readonly ${name} = undefined as unknown as ${type};`);
+            attrs.push(`[${input.alias}]="${name}"`);
+        }
+        const tag = selector.tag ?? 'div';
+        const open = `<${tag}${attrs.length ? ' ' + attrs.join(' ') : ''}>`;
+        counts[declarable.kind === 'component' ? 'components' : 'directives']++;
+        return VOID_ELEMENTS.has(tag.toLowerCase()) ? open : `${open}</${tag}>`;
+    };
+    const pipeUse = (pipe, fields) => {
+        if (!fields.some((f) => f.includes('pipeValue'))) {
+            fields.push('  protected readonly pipeValue: any = undefined;', '  protected readonly pipeArg: any = undefined;');
+        }
+        counts.pipes++;
+        const args = Array.from({ length: pipe.extraArgs }, () => ' : pipeArg').join('');
+        return `<span>{{ pipeValue | ${pipe.pipeName}${args} }}</span>`;
+    };
+    // An NgModule, with everything it exports used in one template, as its users would.
+    for (const module of api.modules) {
+        const use = { imports: [local(module.entry, module.exportName)], template: [], fields: [] };
+        counts.modules++;
+        for (const id of module.exports) {
+            const declarable = api.declarables.find((d) => d.id === id);
+            const pipe = api.pipes.find((p) => p.id === id);
+            const line = declarable ? element(declarable, use.fields) : pipe?.pipeName ? pipeUse(pipe, use.fields) : undefined;
+            if (line)
+                use.template.push(line);
+        }
+        uses.push(use);
+    }
+    // Standalone declarables and pipes, one at a time. Only those with a selector are imported: an
+    // abstract base directive can't go in `imports`, and an unused import is a warning.
+    const importable = (item) => item.standalone && Boolean(item.exportName && item.entry);
+    for (const declarable of api.declarables) {
+        if (!importable(declarable))
+            continue;
+        const use = { imports: [], template: [], fields: [] };
+        const line = element(declarable, use.fields);
+        if (!line)
+            continue;
+        use.imports.push(local(declarable.entry, declarable.exportName));
+        use.template.push(line);
+        uses.push(use);
+    }
+    for (const pipe of api.pipes) {
+        if (!importable(pipe) || !pipe.pipeName)
+            continue;
+        const use = { imports: [local(pipe.entry, pipe.exportName)], template: [], fields: [] };
+        use.template.push(pipeUse(pipe, use.fields));
+        uses.push(use);
+    }
+    const rootFields = [];
+    for (const service of api.services) {
+        const name = local(service.entry, service.exportName);
+        const type = service.typeParams ? `${name}<${Array(service.typeParams).fill('any').join(', ')}>` : name;
+        rootFields.push(`  protected readonly s${field++} = inject<${type}>(${name}, { optional: true });`);
+        counts.services++;
+    }
+    // Namespace imports pull every export into the bundle, so the linker sees every declaration.
+    const namespaces = api.entries.map((entry, i) => `import * as ngmEntry${i} from ${JSON.stringify(entry)};`);
+    rootFields.unshift(`  protected readonly ngmEntries = [${api.entries.map((_, i) => `ngmEntry${i}`).join(', ')}];`);
+    const named = new Map();
+    for (const [key, localName] of names) {
+        const [entry, exportName] = key.split('\u0000');
+        const list = named.get(entry) ?? [];
+        list.push(exportName === localName ? exportName : `${exportName} as ${localName}`);
+        named.set(entry, list);
+    }
+    const namedImports = [...named].map(([entry, list]) => `import { ${list.sort().join(', ')} } from ${JSON.stringify(entry)};`);
+    const coreImports = ['Component', 'CUSTOM_ELEMENTS_SCHEMA', 'inject'];
+    if (options.signalWriteBrand)
+        coreImports.push('ɵINPUT_SIGNAL_BRAND_WRITE_TYPE');
+    const writeHelper = options.signalWriteBrand
+        ? `type NgmWrite<S, I, K extends keyof I> = I[K] extends { [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: infer W }
+  ? W
+  : S extends { [P in \`ngAcceptInputType_\${K & string}\`]: infer A }
+    ? A
+    : I[K];`
+        : `type NgmWrite<S, I, K extends keyof I> = S extends { [P in \`ngAcceptInputType_\${K & string}\`]: infer A } ? A : I[K];`;
+    const component = (name, selector, imports, template, fields) => `@Component({
+  selector: '${selector}',
+  standalone: true,
+  imports: [${imports.join(', ')}],
+  schemas: [CUSTOM_ELEMENTS_SCHEMA],
+  template: \`
+${template.map((line) => '    ' + escapeTemplate(line)).join('\n')}
+  \`,
+})
+${name === 'NgmSmoke' ? 'export ' : ''}class ${name} {
+${fields.join('\n')}
+}
+`;
+    const useNames = uses.map((_, i) => `NgmUse${i}`);
+    const source = `// Generated by ng-matrix: uses every public export of the package once.
+import { ${coreImports.join(', ')} } from '@angular/core';
+${namespaces.join('\n')}
+${namedImports.join('\n')}
+
+/** The type a template binding to this input must have. */
+${writeHelper}
+
+${uses.map((use, i) => component(useNames[i], `ngm-use-${i}`, use.imports, use.template, use.fields)).join('\n')}
+${component('NgmSmoke', 'app-root', useNames, useNames.map((_, i) => `<ngm-use-${i}></ngm-use-${i}>`), rootFields)}`;
+    const main = `// Generated by ng-matrix.
+import { bootstrapApplication } from '@angular/platform-browser';
+import { NgmSmoke } from './ngm-smoke';
+
+bootstrapApplication(NgmSmoke).catch((error) => console.error(error));
+`;
+    return { component: source, main, counts };
+}
+function writeType(className, typeParams, property) {
+    const instance = typeParams ? `${className}<${Array(typeParams).fill('any').join(', ')}>` : className;
+    return `NgmWrite<typeof ${className}, ${instance}, ${JSON.stringify(property)}>`;
+}
+function escapeAttr(value) {
+    return value.replace(/"/g, '&quot;');
+}
+function escapeTemplate(line) {
+    return line.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+export function hasSignalWriteBrand(appDir) {
+    const require = createRequire(join(appDir, 'package.json'));
+    try {
+        const manifest = require.resolve('@angular/core/package.json');
+        const version = JSON.parse(readFileSync(manifest, 'utf8')).version;
+        const [major, minor] = version.split('.').map(Number);
+        return major > 17 || (major === 17 && minor >= 1);
+    }
+    catch {
+        return false;
+    }
+}
+export function writeSmoke(appDir, files) {
+    writeFileSync(join(appDir, 'src', 'ngm-smoke.ts'), files.component);
+    writeFileSync(join(appDir, 'src', 'ngm-main.ts'), files.main);
+}
+export function smokeExists(appDir) {
+    return existsSync(join(appDir, 'src', 'ngm-smoke.ts'));
+}

package/dist/tests.js

@@ -0,0 +1,105 @@
+import { cpSync, rmSync, writeFileSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import semver from 'semver';
+import { readJson, writeJson } from "./app.js";
+import { environmentProblem, errorLines, exec, npm, quietEnv, stepTimeout } from "./exec.js";
+import { FRAMEWORK } from "./peers.js";
+import { npmInstall, pnpmBuildSettings } from "./scripts.js";
+import { ensureTool, PNPM_VERSION, pnpmEntry, pnpmShimDir, withPath } from "./tools.js";
+/** Packages released with the Angular CLI, versioned with it. */
+const TOOLING = /^(@angular\/(cli|build|ssr|pwa)|@angular-devkit\/.+|@schematics\/angular)$/;
+const SKIP = new Set(['node_modules', '.git', '.angular', 'dist', '.nx', '.ng-matrix', 'coverage']);
+/**
+ * The version every Angular-related dependency of the workspace gets for this major:
+ * framework packages match @angular/core, tooling matches the CLI, and TypeScript, zone.js,
+ * RxJS and ng-packagr get the ranges this Angular accepts, for the package manager to resolve.
+ */
+export function swapVersions(deps, request) {
+    const { angular, peerVersions } = request;
+    const out = { ...deps };
+    for (const name of Object.keys(deps)) {
+        if (FRAMEWORK.has(name))
+            out[name] = angular.version;
+        else if (TOOLING.test(name))
+            out[name] = angular.cliVersion;
+        else if (peerVersions[name])
+            out[name] = peerVersions[name];
+        else if (name === 'ng-packagr')
+            out[name] = angular.prerelease ? `>=${angular.major}.0.0-0` : `^${angular.major}.0.0`;
+        else if (name === 'typescript' && angular.typescriptRange)
+            out[name] = angular.typescriptRange;
+        else if (name === 'zone.js' && angular.zoneRange)
+            out[name] = angular.zoneRange;
+        else if (name === 'rxjs' && angular.rxjsRange) {
+            const current = semver.minVersion(deps[name]);
+            if (!current || !semver.satisfies(current, angular.rxjsRange))
+                out[name] = angular.rxjsRange;
+        }
+    }
+    return out;
+}
+/** Runs the library's own tests in a copy of its workspace, with Angular swapped to this version. */
+export async function runLibraryTests(request) {
+    const started = Date.now();
+    rmSync(request.into, { recursive: true, force: true });
+    cpSync(request.workspace, request.into, {
+        recursive: true,
+        filter: (source) => {
+            const rel = relative(request.workspace, source);
+            return !rel || !rel.split(sep).some((part) => SKIP.has(part));
+        },
+    });
+    for (const lock of ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'])
+        rmSync(join(request.into, lock), { force: true });
+    const manifestPath = join(request.into, 'package.json');
+    const manifest = readJson(manifestPath);
+    if (manifest.dependencies)
+        manifest.dependencies = swapVersions(manifest.dependencies, request);
+    if (manifest.devDependencies)
+        manifest.devDependencies = swapVersions(manifest.devDependencies, request);
+    if (request.pm === 'pnpm')
+        manifest.packageManager = `pnpm@${PNPM_VERSION}`;
+    else
+        delete manifest.packageManager;
+    writeJson(manifestPath, manifest);
+    let env = quietEnv({ CI: '1' });
+    let install;
+    if (request.pm === 'npm') {
+        const args = ['install', '--legacy-peer-deps', '--no-audit', '--no-fund'];
+        if (request.offline)
+            args.push('--offline');
+        install = await npmInstall(args, { cwd: request.into, env, timeoutMs: stepTimeout() }, request.allowScripts);
+    }
+    else {
+        writeFileSync(join(request.into, 'pnpm-workspace.yaml'), ['strictPeerDependencies: false', ...pnpmBuildSettings(request.allowScripts)].join('\n') + '\n');
+        const pnpm = await ensureTool(request.cacheDir, 'pnpm', PNPM_VERSION, request.offline);
+        // The test command runs in a shell; it has to find this pnpm, not whatever is (or isn't) installed.
+        env = withPath(env, pnpmShimDir(request.cacheDir, pnpm));
+        install = await exec(process.execPath, [pnpmEntry(pnpm), 'install', '--no-frozen-lockfile'], {
+            cwd: request.into,
+            env,
+            timeoutMs: stepTimeout(),
+        });
+    }
+    if (install.code !== 0) {
+        return {
+            pass: false,
+            message: `Installing the workspace with Angular ${request.angular.version} failed.`,
+            errorLines: errorLines(install.output),
+            fullOutput: install.output,
+            durationMs: Date.now() - started,
+            environment: environmentProblem(install),
+        };
+    }
+    const command = request.command ?? `${request.pm} test`;
+    const result = await exec(command, [], { cwd: request.into, env, shell: true, timeoutMs: stepTimeout() });
+    const tail = result.output.split(/\r?\n/).filter((l) => l.trim()).slice(-8);
+    return {
+        pass: result.code === 0,
+        message: result.code === 0 ? `\`${command}\` passed.` : `\`${command}\` exited with ${result.code}.`,
+        errorLines: result.code === 0 ? tail.slice(-3) : errorLines(result.output),
+        fullOutput: result.output,
+        durationMs: Date.now() - started,
+        environment: result.code === 0 ? undefined : environmentProblem(result),
+    };
+}