fix build working directory issues

Author: CalmDownVal

packages/rollup-util/src/BuildContext.ts

@@ -1,27 +1,37 @@
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 
-import { discoverModule, discoverWorkspace, getDependencies, Module } from "@calmdownval/workspaces-util";
+import { discoverModule, discoverWorkspace, getDependencies } from "@calmdownval/workspaces-util";
 
 export interface BuildContext {
 	readonly cwd: string;
+	readonly moduleName: string;
 	readonly targetEnv: TargetEnv;
+
+	/** @internal */
+	addBuildTask(block: BuildTask): void;
 }
 
 export type TargetEnv =
 	| "development"
 	| "staging"
 	| "production";
 
+/** @internal */
+export interface BuildTask {
+	(context: BuildContext): Promise<void>;
+}
+
 
 let currentContext: BuildContext | null = null;
 
-export function getContext(): BuildContext {
+/** @internal */
+export function runBuild(block: BuildTask) {
 	if (!currentContext) {
 		throw new Error('Could not get build context. Please use the rollup-build command.');
 	}
 
-	return currentContext;
+	currentContext.addBuildTask(block);
 }
 
 const ENV_MAP: { readonly [K in string]?: TargetEnv } = {
@@ -35,40 +45,53 @@ const ENV_MAP: { readonly [K in string]?: TargetEnv } = {
 
 export async function build(cwd: string = process.cwd()) {
 	try {
-		// get the module to build
-		const module = await discoverModule(cwd);
-		if (!module) {
+		// get the origin module to build
+		const originModule = await discoverModule(cwd);
+		if (!originModule) {
 			throw new Error(`No module found at path '${cwd}'.`);
 		}
 
 		// get an ordered queue of dependencies that need to be built
 		const workspace = await discoverWorkspace({ cwd });
-		const queue = workspace
+		const moduleQueue = workspace
 			? getDependencies({
 				workspace,
-				moduleName: module.declaration.name,
+				moduleName: originModule.declaration.name,
 			})
-			: [ module ];
+			: [ originModule ];
 
-		// prepare the context object
+		// get the target environment
 		const targetEnv: TargetEnv = process.env.BUILD_ENV
 			? ENV_MAP[process.env.BUILD_ENV] ?? "production"
 			: "production";
 
-		const context: BuildContext = {
-			cwd,
-			targetEnv,
-		};
-
 		// build!
-		for (const currentModule of queue) {
+		for (const currentModule of moduleQueue) {
+			const taskQueue: BuildTask[] = [];
 			currentContext = {
-				...context,
 				cwd: currentModule.baseDir,
+				moduleName: currentModule.declaration.name,
+				targetEnv,
+				addBuildTask: block => {
+					taskQueue.push(block);
+				},
+			};
+
+			// import the build.targets.mjs definition file
+			process.chdir(currentContext.cwd);
+			try {
+				const url = pathToFileURL(join(currentContext.cwd, "build.targets.mjs")).href;
+				await import(url);
+			}
+			catch {
+				// likely no such file exists, skip it...
+				continue;
 			}
 
-			const url = pathToFileURL(join(currentContext.cwd, "build.targets.mjs")).href;
-			await import(url);
+			// run queued tasks
+			for (const task of taskQueue) {
+				await task(currentContext);
+			}
 		}
 	}
 	finally {

packages/rollup-util/src/Plugin.ts

@@ -1,28 +1,30 @@
+import type { Plugin as RollupPlugin } from "rollup";
+
 import type { BuildContext } from "./BuildContext";
 
 /**
  * A Rollup plugin declaration. Manages its import logic and configuration.
  */
-export interface Plugin<TName extends string, TConfig, TInstance> {
+export interface Plugin<TName extends string, TConfig> {
 	readonly name: TName;
 
 	/** @internal */
-	readonly factory: PluginFactoryBlock<TConfig, TInstance>;
+	readonly factory: PluginFactoryBlock<TConfig>;
 
 	/** @internal */
 	readonly configure: PluginConfigBlock<TConfig>;
 
 	override(
 		configOverride: Partial<TConfig>,
-	): Plugin<TName, TConfig, TInstance>;
+	): Plugin<TName, TConfig>;
 
 	override(
 		block: PluginConfigOverrideBlock<TConfig>,
-	): Plugin<TName, TConfig, TInstance>;
+	): Plugin<TName, TConfig>;
 }
 
-export interface PluginFactoryBlock<TConfig, TInstance> {
-	(config: TConfig, context: BuildContext): Promise<TInstance> | TInstance;
+export interface PluginFactoryBlock<TConfig> {
+	(context: BuildContext): Promise<PluginFactory<TConfig>> | PluginFactory<TConfig>;
 }
 
 export interface PluginConfigBlock<TConfig> {
@@ -33,41 +35,45 @@ export interface PluginConfigOverrideBlock<TConfig> {
 	(config: TConfig, context: BuildContext): Promise<TConfig> | TConfig;
 }
 
+export interface PluginFactory<TConfig> {
+	(config: TConfig): RollupPlugin;
+}
+
 export interface PluginFactoryBuilder<TName extends string> {
 	/** @internal */
 	readonly name: TName;
 
-	factory<TConfig, TInstance>(
-		block: PluginFactoryBlock<TConfig, TInstance>,
-	): PluginConfigurationBuilder<TName, TConfig, TInstance>;
+	factory<TConfig>(
+		block: PluginFactoryBlock<TConfig>,
+	): PluginConfigurationBuilder<TName, TConfig>;
 }
 
-export interface PluginConfigurationBuilder<TName extends string, TConfig, TInstance> {
+export interface PluginConfigurationBuilder<TName extends string, TConfig> {
 	/** @internal */
 	readonly name: TName;
 
 	/** @internal */
-	readonly factory: PluginFactoryBlock<TConfig, TInstance>;
+	readonly factory: PluginFactoryBlock<TConfig>;
 
-	configure<TConfig>(
+	configure(
 		config: TConfig,
-	): Plugin<TName, TConfig, TInstance>;
+	): Plugin<TName, TConfig>;
 
-	configure<TConfig>(
+	configure(
 		block: PluginConfigBlock<TConfig>
-	): Plugin<TName, TConfig, TInstance>;
+	): Plugin<TName, TConfig>;
 }
 
 export type NameOf<TPlugin> = (
-	TPlugin extends Plugin<infer TName, any, any> ? TName : unknown
+	TPlugin extends Plugin<infer TName, any> ? TName : unknown
 );
 
 export type ConfigOf<TPlugin> = (
-	TPlugin extends Plugin<any, infer TConfig, any> ? TConfig : unknown
+	TPlugin extends Plugin<any, infer TConfig> ? TConfig : unknown
 );
 
 export type AnyPlugin = (
-	Plugin<any, any, any>
+	Plugin<any, any>
 );
 
 export type PluginMap = {
@@ -83,8 +89,8 @@ export function declarePlugin<TName extends string>(name: TName): PluginFactoryB
 
 function setPluginFactory(
 	this: PluginFactoryBuilder<any>,
-	block: PluginFactoryBlock<any, any>
-): PluginConfigurationBuilder<any, any, any> {
+	block: PluginFactoryBlock<any>
+): PluginConfigurationBuilder<any, any> {
 	return {
 		name: this.name,
 		factory: block,
@@ -93,7 +99,7 @@ function setPluginFactory(
 }
 
 function configurePlugin(
-	this: PluginConfigurationBuilder<any, any, any>,
+	this: PluginConfigurationBuilder<any, any>,
 	configOrBlock: any,
 ): AnyPlugin {
 	return {

packages/rollup-util/src/Target.ts

@@ -1,7 +1,9 @@
+import { resolve } from "node:path";
+
 import { rollup, type OutputOptions as TargetConfig } from "rollup";
 
 import type { AnyPlugin, ConfigOf, NameOf, PluginConfigOverrideBlock, PluginMap } from "./Plugin";
-import { getContext, type BuildContext } from "./BuildContext";
+import { runBuild, type BuildContext } from "./BuildContext";
 
 export interface Target<TName extends string, TPlugins extends PluginMap> {
 	readonly name: TName;
@@ -15,7 +17,7 @@ export interface Target<TName extends string, TPlugins extends PluginMap> {
 	/** @internal */
 	readonly configure: TargetConfigBlock;
 
-	build(): Promise<void>;
+	build(): void;
 
 	entry(
 		unit: string,
@@ -106,23 +108,23 @@ function configureTarget(
 	};
 }
 
-async function buildTarget(
+function buildTarget(
 	this: Target<any, any>,
 ) {
-	const context = getContext();
-	process.chdir(context.cwd);
-
-	const bundle = await rollup({
-		input: this.entries,
-		plugins: Promise.all(this.plugins.map(async it => {
-			const pluginConfig = await it.configure(context);
-			const instance = await it.factory(pluginConfig, context);
-			return instance;
-		}))
+	runBuild(async context => {
+		const inputConfig = {
+			input: this.entries,
+			plugins: Promise.all(this.plugins.map(async it => {
+				const pluginConfig = await it.configure(context);
+				const factory = await it.factory(context);
+				return factory(pluginConfig);
+			}))
+		};
+
+		const bundle = await rollup(inputConfig);
+		const outputConfig = await this.configure(context);
+		await bundle.write(outputConfig);
 	});
-
-	const outputConfig = await this.configure(context);
-	bundle.write(outputConfig);
 }
 
 function addTargetEntry(

packages/rollup-util/src/index.ts

@@ -11,6 +11,7 @@ export {
 	type PluginConfigBlock,
 	type PluginConfigOverrideBlock,
 	type PluginFactoryBuilder,
+	type PluginFactory,
 	type PluginConfigurationBuilder,
 	type NameOf,
 	type ConfigOf,

packages/workspaces-util/src/dependencies.ts

@@ -35,6 +35,7 @@ export type DependencyMapKey =
 const DEFAULT_DEPENDENCY_MAPS: DependencyMapKey[] = [
 	"dependencies",
 	"devDependencies",
+	"peerDependencies",
 ];
 
 function buildGraph(workspace: Workspace, options?: GraphOptions): Graph {
@@ -92,7 +93,7 @@ function createTraversal(
 	direction: "push" | "unshift",
 ): DependencyTraversal {
 	return options => {
-		const graph = buildGraph(options.workspace);
+		const graph = buildGraph(options.workspace, options);
 		const origin = graph[options.moduleName];
 		if (!origin) {
 			throw new Error(`No module '${options.moduleName}' could be found in the workspace.`);
@@ -131,9 +132,11 @@ function createTraversal(
 			node.visiting = false;
 			node.visited = true;
 
-			if (node !== origin && options.includeSelf !== false) {
+			if (node !== origin || options.includeSelf !== false) {
 				result[direction](node.module);
 			}
+
+			return true;
 		};
 
 		visit(origin);