build.mts

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.dev/license
 */

import{spawn}from'node:child_process';
import{COPYFILE_FICLONE}from'node:constants';
importfsfrom'node:fs';
importpath,{dirname,join,relative,resolve}from'node:path';
import{fileURLToPath}from'node:url';

const__dirname=path.dirname(fileURLToPath(import.meta.url));
constbaseDir=resolve(`${__dirname}/..`);
constbazelCmd=process.env.BAZEL??`pnpm -s bazel`;
constdistRoot=join(baseDir,'/dist');

typeBuildMode='local'|'snapshot'|'release';

function_copy(from: string,to: string){
// Create parent folder if necessary.
if(!fs.existsSync(dirname(to))){
fs.mkdirSync(dirname(to),{recursive: true});
}

// Error out if destination already exists.
if(fs.existsSync(to)){
thrownewError(`Path ${to} already exist...`);
}

from=relative(process.cwd(),from);
to=relative(process.cwd(),to);

fs.copyFileSync(from,to,COPYFILE_FICLONE);
}

function_recursiveCopy(from: string,to: string,logger: Console){
if(!fs.existsSync(from)){
logger.error(`File "${from}" does not exist.`);
process.exit(4);
}
if(fs.statSync(from).isDirectory()){
fs.readdirSync(from).forEach((fileName)=>{
_recursiveCopy(join(from,fileName),join(to,fileName),logger);
});
}else{
_copy(from,to);
}
}

function_clean(logger: Console){
logger.info('Cleaning...');
logger.info(' Removing dist/...');

returnfs.promises.rm(join(__dirname,'../dist'),{
force: true,
recursive: true,
maxRetries: 3,
});
}

function_exec(cmd: string,captureStdout: boolean,logger: Console): Promise<string>{
returnnewPromise((resolve,reject)=>{
constproc=spawn(cmd,{
stdio: 'pipe',
shell: true,
cwd: baseDir,
});

letoutput='';
proc.stdout.on('data',(data)=>{
logger.info(data.toString().trim());
if(captureStdout){
output+=data.toString().trim();
}
});
proc.stderr.on('data',(data)=>logger.info(data.toString().trim()));

proc.on('error',(error)=>{
logger.error(error.message);
});

proc.on('exit',(status)=>{
if(status!==0){
reject(`Command failed: ${cmd}`);
}else{
resolve(output);
}
});
});
}

asyncfunction_build(logger: Console,mode: BuildMode): Promise<string[]>{
logger.group(`Building (mode=${mode})...`);

logger.group('Finding targets...');
constqueryTargetsCmd=`${bazelCmd} query --output=label "attr(name, npm_package_archive, //packages/...)"`;
consttargets=(await_exec(queryTargetsCmd,true,logger)).split(/\r?\n/);
logger.groupEnd();

// If we are in release mode, run `bazel clean` to ensure the execroot and action cache
// are not populated. This is necessary because targets using `npm_package` rely on
// workspace status variables for the package version. Such NPM package targets are not
// rebuilt if only the workspace status variables change. This could result in accidental
// re-use of previously built package output with a different `version` in the `package.json`.
if(mode=='release'){
logger.info('Building in release mode. Resetting the Bazel execroot and action cache.');
await_exec(`${bazelCmd} clean`,false,logger);
}

logger.group('Building targets...');
await_exec(`${bazelCmd} build --config=${mode}${targets.join(' ')}`,false,logger);
logger.groupEnd();

logger.groupEnd();

returntargets;
}

exportdefaultasyncfunction(
argv: {local?: boolean;snapshot?: boolean}={},
): Promise<{name: string;outputPath: string;tarPath: string}[]>{
constlogger=globalThis.console;

constbazelBin=await_exec(`${bazelCmd} info bazel-bin`,true,logger);

await_clean(logger);

letbuildMode: BuildMode;
if(argv.local){
buildMode='local';
}elseif(argv.snapshot){
buildMode='snapshot';
}else{
buildMode='release';
}

consttargets=await_build(logger,buildMode);
constoutput=[];

logger.group('Moving packages and tars to dist/');

for(consttargetoftargets){
constpackageDir=target.replace(/\/\/packages\/(.*):npm_package_archive/,'$1');
constbazelOutDir=join(bazelBin,'packages',packageDir,'npm_package');
consttarPathInBin=`${bazelBin}/packages/${packageDir}/npm_package_archive.tgz`;
constpackageJsonPath=`${bazelOutDir}/package.json`;
constpackageName=JSON.parse(fs.readFileSync(packageJsonPath,'utf8')).name;
constdestDir=`${distRoot}/${packageName}`;

logger.info(packageName);

_recursiveCopy(bazelOutDir,destDir,logger);
consttarPath=`${distRoot}/${packageName.replace('@','_').replace('/','_')}.tgz`;
_copy(tarPathInBin,tarPath);

output.push({name: packageDir,outputPath: destDir, tarPath });
}

logger.groupEnd();

returnoutput;
}