@ui5/builder 3.0.0-alpha.5 → 3.0.0-alpha.8

package/lib/builder/builder.js

@@ -1,425 +0,0 @@
-const {promisify} = require("util");
-const rimraf = promisify(require("rimraf"));
-const log = require("@ui5/logger").getGroupLogger("builder:builder");
-const resourceFactory = require("@ui5/fs").resourceFactory;
-const MemAdapter = require("@ui5/fs").adapters.Memory;
-const typeRepository = require("../types/typeRepository");
-const taskRepository = require("../tasks/taskRepository");
-const BuildContext = require("./BuildContext");
-
-
-// Set of tasks for development
-const devTasks = [
-	"replaceCopyright",
-	"replaceVersion",
-	"replaceBuildtime",
-	"buildThemes"
-];
-
-/**
- * Calculates the elapsed build time and returns a prettified output
- *
- * @private
- * @param {Array} startTime Array provided by <code>process.hrtime()</code>
- * @returns {string} Difference between now and the provided time array as formatted string
- */
-function getElapsedTime(startTime) {
-	const prettyHrtime = require("pretty-hrtime");
-	const timeDiff = process.hrtime(startTime);
-	return prettyHrtime(timeDiff);
-}
-
-/**
- * Creates the list of tasks to be executed by the build process
- *
- * Sets specific tasks to be disabled by default, these tasks need to be included explicitly.
- * Based on the selected build mode (dev|selfContained|preload), different tasks are enabled.
- * Tasks can be enabled or disabled. The wildcard <code>*</code> is also supported and affects all tasks.
- *
- * @private
- * @param {object} parameters
- * @param {boolean} parameters.dev Sets development mode, which only runs essential tasks
- * @param {boolean} parameters.selfContained
- *			True if a the build should be self-contained or false for prelead build bundles
- * @param {boolean} parameters.jsdoc True if a JSDoc build should be executed
- * @param {Array} parameters.includedTasks Task list to be included from build
- * @param {Array} parameters.excludedTasks Task list to be excluded from build
- * @returns {Array} Return a task list for the builder
- */
-function composeTaskList({dev, selfContained, jsdoc, includedTasks, excludedTasks}) {
-	const definedTasks = taskRepository.getAllTaskNames();
-	let selectedTasks = definedTasks.reduce((list, key) => {
-		list[key] = true;
-		return list;
-	}, {});
-
-	// Exclude non default tasks
-	selectedTasks.generateManifestBundle = false;
-	selectedTasks.generateStandaloneAppBundle = false;
-	selectedTasks.transformBootstrapHtml = false;
-	selectedTasks.generateJsdoc = false;
-	selectedTasks.executeJsdocSdkTransformation = false;
-	selectedTasks.generateCachebusterInfo = false;
-	selectedTasks.generateApiIndex = false;
-	selectedTasks.generateThemeDesignerResources = false;
-
-	// Disable generateResourcesJson due to performance.
-	// When executed it analyzes each module's AST and therefore
-	// takes up much time (~10% more)
-	selectedTasks.generateResourcesJson = false;
-
-	if (selfContained) {
-		// No preloads, bundle only
-		selectedTasks.generateComponentPreload = false;
-		selectedTasks.generateStandaloneAppBundle = true;
-		selectedTasks.transformBootstrapHtml = true;
-		selectedTasks.generateLibraryPreload = false;
-	}
-
-	// TODO 3.0: exclude generateVersionInfo if not --all is used
-
-	if (jsdoc) {
-		// Include JSDoc tasks
-		selectedTasks.generateJsdoc = true;
-		selectedTasks.executeJsdocSdkTransformation = true;
-		selectedTasks.generateApiIndex = true;
-
-		// Include theme build as required for SDK
-		selectedTasks.buildThemes = true;
-
-		// Exclude all tasks not relevant to JSDoc generation
-		selectedTasks.replaceCopyright = false;
-		selectedTasks.replaceVersion = false;
-		selectedTasks.replaceBuildtime = false;
-		selectedTasks.generateComponentPreload = false;
-		selectedTasks.generateLibraryPreload = false;
-		selectedTasks.generateLibraryManifest = false;
-		selectedTasks.minify = false;
-		selectedTasks.generateFlexChangesBundle = false;
-		selectedTasks.generateManifestBundle = false;
-	}
-
-	// Only run essential tasks in development mode, it is not desired to run time consuming tasks during development.
-	if (dev) {
-		// Overwrite all other tasks with noop promise
-		Object.keys(selectedTasks).forEach((key) => {
-			if (devTasks.indexOf(key) === -1) {
-				selectedTasks[key] = false;
-			}
-		});
-	}
-
-	// Exclude tasks
-	for (let i = 0; i < excludedTasks.length; i++) {
-		const taskName = excludedTasks[i];
-		if (taskName === "*") {
-			Object.keys(selectedTasks).forEach((sKey) => {
-				selectedTasks[sKey] = false;
-			});
-			break;
-		}
-		if (selectedTasks[taskName] === true) {
-			selectedTasks[taskName] = false;
-		} else if (typeof selectedTasks[taskName] === "undefined") {
-			log.warn(`Unable to exclude task '${taskName}': Task is unknown`);
-		}
-	}
-
-	// Include tasks
-	for (let i = 0; i < includedTasks.length; i++) {
-		const taskName = includedTasks[i];
-		if (taskName === "*") {
-			Object.keys(selectedTasks).forEach((sKey) => {
-				selectedTasks[sKey] = true;
-			});
-			break;
-		}
-		if (selectedTasks[taskName] === false) {
-			selectedTasks[taskName] = true;
-		} else if (typeof selectedTasks[taskName] === "undefined") {
-			log.warn(`Unable to include task '${taskName}': Task is unknown`);
-		}
-	}
-
-	// Filter only for tasks that will be executed
-	selectedTasks = Object.keys(selectedTasks).filter((task) => selectedTasks[task]);
-
-	return selectedTasks;
-}
-
-async function executeCleanupTasks(buildContext) {
-	log.info("Executing cleanup tasks...");
-	await buildContext.executeCleanupTasks();
-}
-
-function registerCleanupSigHooks(buildContext) {
-	function createListener(exitCode) {
-		return function() {
-			// Asynchronously cleanup resources, then exit
-			executeCleanupTasks(buildContext).then(() => {
-				process.exit(exitCode);
-			});
-		};
-	}
-
-	const processSignals = {
-		"SIGHUP": createListener(128 + 1),
-		"SIGINT": createListener(128 + 2),
-		"SIGTERM": createListener(128 + 15),
-		"SIGBREAK": createListener(128 + 21)
-	};
-
-	for (const signal of Object.keys(processSignals)) {
-		process.on(signal, processSignals[signal]);
-	}
-
-	// == TO BE DISCUSSED: Also cleanup for unhandled rejections and exceptions?
-	// Add additional events like signals since they are registered on the process
-	//	event emitter in a similar fashion
-	// processSignals["unhandledRejection"] = createListener(1);
-	// process.once("unhandledRejection", processSignals["unhandledRejection"]);
-	// processSignals["uncaughtException"] = function(err, origin) {
-	// 	const fs = require("fs");
-	// 	fs.writeSync(
-	// 		process.stderr.fd,
-	// 		`Caught exception: ${err}\n` +
-	// 		`Exception origin: ${origin}`
-	// 	);
-	// 	createListener(1)();
-	// };
-	// process.once("uncaughtException", processSignals["uncaughtException"]);
-
-	return processSignals;
-}
-
-function deregisterCleanupSigHooks(signals) {
-	for (const signal of Object.keys(signals)) {
-		process.removeListener(signal, signals[signal]);
-	}
-}
-
-/**
- * Builder
- *
- * @public
- * @namespace
- * @alias module:@ui5/builder.builder
- */
-module.exports = {
-	/**
-	 * Configures the project build and starts it.
-	 *
-	 * @public
-	 * @param {object} parameters Parameters
-	 * @param {object} parameters.tree Project tree as generated by the
-	 * 									[@ui5/project.normalizer]{@link module:@ui5/project.normalizer}
-	 * @param {string} parameters.destPath Target path
-	 * @param {boolean} [parameters.cleanDest=false] Decides whether project should clean the target path before build
-	 * @param {boolean} [parameters.buildDependencies=false] Decides whether project dependencies are built as well
-	 * @param {Array.<string|RegExp>} [parameters.includedDependencies=[]]
-	 *			List of build dependencies to be included if buildDependencies is true
-	 * @param {Array.<string|RegExp>} [parameters.excludedDependencies=[]]
-	 *			List of build dependencies to be excluded if buildDependencies is true.
-	 *			If the wildcard '*' is provided, only the included dependencies will be built.
-	 * @param {boolean} [parameters.dev=false]
-	 *			Decides whether a development build should be activated (skips non-essential and time-intensive tasks)
-	 * @param {boolean} [parameters.selfContained=false] Flag to activate self contained build
-	 * @param {boolean} [parameters.cssVariables=false] Flag to activate CSS variables generation
-	 * @param {boolean} [parameters.jsdoc=false] Flag to activate JSDoc build
-	 * @param {Array.<string>} [parameters.includedTasks=[]] List of tasks to be included
-	 * @param {Array.<string>} [parameters.excludedTasks=[]] List of tasks to be excluded.
-	 * 							If the wildcard '*' is provided, only the included tasks will be executed.
-	 * @param {Array.<string>} [parameters.devExcludeProject=[]] List of projects to be excluded from development build
-	 * @returns {Promise} Promise resolving to <code>undefined</code> once build has finished
-	 */
-	async build({
-		tree, destPath, cleanDest = false,
-		buildDependencies = false, includedDependencies = [], excludedDependencies = [],
-		dev = false, selfContained = false, cssVariables = false, jsdoc = false,
-		includedTasks = [], excludedTasks = [], devExcludeProject = []
-	}) {
-		const startTime = process.hrtime();
-		log.info(`Building project ${tree.metadata.name}` + (buildDependencies ? "" : " not") +
-			" including dependencies..." + (dev ? " [dev mode]" : ""));
-		log.verbose(`Building to ${destPath}...`);
-
-		const selectedTasks = composeTaskList({dev, selfContained, jsdoc, includedTasks, excludedTasks});
-
-		const fsTarget = resourceFactory.createAdapter({
-			fsBasePath: destPath,
-			virBasePath: "/"
-		});
-
-		const buildContext = new BuildContext({
-			rootProject: tree,
-			options: {
-				cssVariables: cssVariables
-			}
-		});
-		const cleanupSigHooks = registerCleanupSigHooks(buildContext);
-
-		const projects = {}; // Unique project index to prevent building the same project multiple times
-		const projectWriters = {}; // Collection of memory adapters of already built libraries
-		function projectFilter(project) {
-			function projectMatchesAny(deps) {
-				return deps.some((dep) => dep instanceof RegExp ?
-					dep.test(project.metadata.name) : dep === project.metadata.name);
-			}
-
-			// if everything is included, this overrules exclude lists
-			if (includedDependencies.includes("*")) return true;
-			let test = !excludedDependencies.includes("*"); // exclude everything?
-
-			if (test && projectMatchesAny(excludedDependencies)) {
-				test = false;
-			}
-			if (!test && projectMatchesAny(includedDependencies)) {
-				test = true;
-			}
-
-			return test;
-		}
-
-		const projectCountMarker = {};
-		function projectCount(project, count = 0) {
-			if (buildDependencies) {
-				count = project.dependencies.filter(projectFilter).reduce((depCount, depProject) => {
-					return projectCount(depProject, depCount);
-				}, count);
-			}
-			if (!projectCountMarker[project.metadata.name]) {
-				count++;
-				projectCountMarker[project.metadata.name] = true;
-			}
-			return count;
-		}
-		const buildLogger = log.createTaskLogger("🛠 ", projectCount(tree));
-
-		function buildProject(project) {
-			const projectBasePath = `/resources/${project.metadata.namespace}`;
-			let depPromise;
-			let projectTasks = selectedTasks;
-
-			// Build dependencies in sequence as it is far easier to detect issues and reduces
-			// side effects or other issues such as too many open files
-			if (buildDependencies) {
-				depPromise = project.dependencies.filter(projectFilter).reduce(function(p, depProject) {
-					return p.then(() => buildProject(depProject));
-				}, Promise.resolve());
-			} else {
-				depPromise = Promise.resolve();
-			}
-
-			// Build the project after all dependencies have been built
-			return depPromise.then(() => {
-				if (projects[project.metadata.name]) {
-					return Promise.resolve();
-				} else {
-					projects[project.metadata.name] = true;
-				}
-				buildLogger.startWork(`Building project ${project.metadata.name}`);
-
-				const projectType = typeRepository.getType(project.type);
-				const resourceCollections = resourceFactory.createCollectionsForTree(project, {
-					virtualReaders: projectWriters,
-					getVirtualBasePathPrefix: function({project, virBasePath}) {
-						if (project.type === "application" && project.metadata.namespace) {
-							return projectBasePath;
-						}
-					},
-					getProjectExcludes: function(project) {
-						if (project.builder && project.builder.resources) {
-							return project.builder.resources.excludes;
-						}
-					}
-				});
-
-				const writer = new MemAdapter({
-					virBasePath: "/"
-				});
-				// Store project writer as virtual reader for parent projects
-				//	so they can access the build results of this project
-				projectWriters[project.metadata.name] = writer;
-
-				// TODO: Add getter for writer of DuplexColection
-				const workspace = resourceFactory.createWorkspace({
-					virBasePath: "/",
-					writer,
-					reader: resourceCollections.source,
-					name: project.metadata.name
-				});
-
-				const projectContext = buildContext.createProjectContext({
-					project, // TODO 2.0: Add project facade object/instance here
-					resources: {
-						workspace,
-						dependencies: resourceCollections.dependencies
-					}
-				});
-
-				const TaskUtil = require("../tasks/TaskUtil");
-				const taskUtil = new TaskUtil({
-					projectBuildContext: projectContext
-				});
-
-				if (dev && devExcludeProject.indexOf(project.metadata.name) !== -1) {
-					projectTasks = composeTaskList({dev: false, selfContained, includedTasks, excludedTasks});
-				}
-
-				return projectType.build({
-					resourceCollections: {
-						workspace,
-						dependencies: resourceCollections.dependencies
-					},
-					tasks: projectTasks,
-					project,
-					parentLogger: log,
-					taskUtil
-				}).then(() => {
-					log.verbose("Finished building project %s. Writing out files...", project.metadata.name);
-					buildLogger.completeWork(1);
-
-					return workspace.byGlob("/**/*").then((resources) => {
-						const tagCollection = projectContext.getResourceTagCollection();
-						return Promise.all(resources.map((resource) => {
-							if (tagCollection.getTag(resource, projectContext.STANDARD_TAGS.OmitFromBuildResult)) {
-								log.verbose(`Skipping write of resource tagged as "OmitFromBuildResult": ` +
-									resource.getPath());
-								return; // Skip target write for this resource
-							}
-							if (projectContext.isRootProject() && project.type === "application" &&
-									project.metadata.namespace) {
-								// Root-application projects only: Remove namespace prefix if given
-								const resourcePath = resource.getPath();
-								if (resourcePath.startsWith(projectBasePath)) {
-									resource.setPath(resourcePath.replace(projectBasePath, ""));
-								}
-							}
-							return fsTarget.write(resource);
-						}));
-					});
-				});
-			});
-		}
-
-		try {
-			if (cleanDest) {
-				await rimraf(destPath);
-			}
-			await buildProject(tree);
-			log.info(`Build succeeded in ${getElapsedTime(startTime)}`);
-		} catch (err) {
-			log.error(`Build failed in ${getElapsedTime(startTime)}`);
-			throw err;
-		} finally {
-			deregisterCleanupSigHooks(cleanupSigHooks);
-			await executeCleanupTasks(buildContext);
-		}
-	}
-};
-
-// Export local function for testing only
-/* istanbul ignore else */
-if (process.env.NODE_ENV === "test") {
-	module.exports._composeTaskList = composeTaskList;
-}

package/lib/types/AbstractBuilder.js

@@ -1,270 +0,0 @@
-
-/**
- * Resource collections
- *
- * @public
- * @typedef module:@ui5/builder.BuilderResourceCollections
- * @property {module:@ui5/fs.DuplexCollection} workspace Workspace Resource
- * @property {module:@ui5/fs.ReaderCollection} dependencies Workspace Resource
- */
-
-/**
- * Base class for the builder implementation of a project type
- *
- * @abstract
- */
-class AbstractBuilder {
-	/**
-	 * Constructor
-	 *
-	 * @param {object} parameters
-	 * @param {BuilderResourceCollections} parameters.resourceCollections Resource collections
-	 * @param {object} parameters.project Project configuration
-	 * @param {GroupLogger} parameters.parentLogger Logger to use
-	 * @param {object} parameters.taskUtil
-	 */
-	constructor({resourceCollections, project, parentLogger, taskUtil}) {
-		if (new.target === AbstractBuilder) {
-			throw new TypeError("Class 'AbstractBuilder' is abstract");
-		}
-
-		this.project = project;
-
-		this.log = parentLogger.createSubLogger(project.type + " " + project.metadata.name, 0.2);
-		this.taskLog = this.log.createTaskLogger("🔨");
-
-		this.tasks = {};
-		this.taskExecutionOrder = [];
-		this.addStandardTasks({
-			resourceCollections,
-			project,
-			log: this.log,
-			taskUtil
-		});
-		this.addCustomTasks({
-			resourceCollections,
-			project,
-			taskUtil
-		});
-	}
-
-	/**
-	 * Adds all standard tasks to execute
-	 *
-	 * @abstract
-	 * @protected
-	 * @param {object} parameters
-	 * @param {BuilderResourceCollections} parameters.resourceCollections Resource collections
-	 * @param {object} parameters.taskUtil
-	 * @param {object} parameters.project Project configuration
-	 * @param {object} parameters.log <code>@ui5/logger</code> logger instance
-	 */
-	addStandardTasks({resourceCollections, project, log, taskUtil}) {
-		throw new Error("Function 'addStandardTasks' is not implemented");
-	}
-
-	/**
-	 * Adds custom tasks to execute
-	 *
-	 * @private
-	 * @param {object} parameters
-	 * @param {BuilderResourceCollections} parameters.resourceCollections Resource collections
-	 * @param {object} parameters.taskUtil
-	 * @param {object} parameters.project Project configuration
-	 */
-	addCustomTasks({resourceCollections, project, taskUtil}) {
-		const projectCustomTasks = project.builder && project.builder.customTasks;
-		if (!projectCustomTasks || projectCustomTasks.length === 0) {
-			return; // No custom tasks defined
-		}
-		const taskRepository = require("../tasks/taskRepository");
-		for (let i = 0; i < projectCustomTasks.length; i++) {
-			const taskDef = projectCustomTasks[i];
-			if (!taskDef.name) {
-				throw new Error(`Missing name for custom task definition of project ${project.metadata.name} ` +
-					`at index ${i}`);
-			}
-			if (taskDef.beforeTask && taskDef.afterTask) {
-				throw new Error(`Custom task definition ${taskDef.name} of project ${project.metadata.name} ` +
-					`defines both "beforeTask" and "afterTask" parameters. Only one must be defined.`);
-			}
-			if (this.taskExecutionOrder.length && !taskDef.beforeTask && !taskDef.afterTask) {
-				// Iff there are tasks configured, beforeTask or afterTask must be given
-				throw new Error(`Custom task definition ${taskDef.name} of project ${project.metadata.name} ` +
-					`defines neither a "beforeTask" nor an "afterTask" parameter. One must be defined.`);
-			}
-
-			let newTaskName = taskDef.name;
-			if (this.tasks[newTaskName]) {
-				// Task is already known
-				// => add a suffix to allow for multiple configurations of the same task
-				let suffixCounter = 0;
-				while (this.tasks[newTaskName]) {
-					suffixCounter++; // Start at 1
-					newTaskName = `${taskDef.name}--${suffixCounter}`;
-				}
-			}
-			// Create custom task if not already done (task might be referenced multiple times, first one wins)
-			const {specVersion, task} = taskRepository.getTask(taskDef.name);
-			const execTask = function() {
-				/* Custom Task Interface
-					Parameters:
-						{Object} parameters Parameters
-						{module:@ui5/fs.DuplexCollection} parameters.workspace DuplexCollection to read and write files
-						{module:@ui5/fs.AbstractReader} parameters.dependencies
-							Reader or Collection to read dependency files
-						{Object} parameters.taskUtil Specification Version dependent interface to a
-							[TaskUtil]{@link module:@ui5/builder.tasks.TaskUtil} instance
-						{Object} parameters.options Options
-						{string} parameters.options.projectName Project name
-						{string} [parameters.options.projectNamespace] Project namespace if available
-						{string} [parameters.options.configuration] Task configuration if given in ui5.yaml
-					Returns:
-						{Promise<undefined>} Promise resolving with undefined once data has been written
-				*/
-				const params = {
-					workspace: resourceCollections.workspace,
-					dependencies: resourceCollections.dependencies,
-					options: {
-						projectName: project.metadata.name,
-						projectNamespace: project.metadata.namespace,
-						configuration: taskDef.configuration
-					}
-				};
-
-				const taskUtilInterface = taskUtil.getInterface(specVersion);
-				// Interface is undefined if specVersion does not support taskUtil
-				if (taskUtilInterface) {
-					params.taskUtil = taskUtilInterface;
-				}
-				return task(params);
-			};
-
-			this.tasks[newTaskName] = execTask;
-
-			if (this.taskExecutionOrder.length) {
-				// There is at least one task configured. Use before- and afterTask to add the custom task
-				const refTaskName = taskDef.beforeTask || taskDef.afterTask;
-				let refTaskIdx = this.taskExecutionOrder.indexOf(refTaskName);
-				if (refTaskIdx === -1) {
-					throw new Error(`Could not find task ${refTaskName}, referenced by custom task ${newTaskName}, ` +
-						`to be scheduled for project ${project.metadata.name}`);
-				}
-				if (taskDef.afterTask) {
-					// Insert after index of referenced task
-					refTaskIdx++;
-				}
-				this.taskExecutionOrder.splice(refTaskIdx, 0, newTaskName);
-			} else {
-				// There is no task configured so far. Just add the custom task
-				this.taskExecutionOrder.push(newTaskName);
-			}
-		}
-	}
-
-	/**
-	 * Adds a executable task to the builder
-	 *
-	 * The order this function is being called defines the build order. FIFO.
-	 *
-	 * @param {string} taskName Name of the task which should be in the list availableTasks.
-	 * @param {Function} taskFunction
-	 */
-	addTask(taskName, taskFunction) {
-		if (this.tasks[taskName]) {
-			throw new Error(`Failed to add duplicate task ${taskName} for project ${this.project.metadata.name}`);
-		}
-		if (this.taskExecutionOrder.includes(taskName)) {
-			throw new Error(`Builder: Failed to add task ${taskName} for project ${this.project.metadata.name}. ` +
-				`It has already been scheduled for execution.`);
-		}
-		this.tasks[taskName] = taskFunction;
-		this.taskExecutionOrder.push(taskName);
-	}
-
-	/**
-	 * Check whether a task is defined
-	 *
-	 * @private
-	 * @param {string} taskName
-	 * @returns {boolean}
-	 */
-	hasTask(taskName) {
-		// TODO 3.0: Check whether this method is still required.
-		// Only usage within #build seems to be unnecessary as all tasks are also added to the taskExecutionOrder
-		return Object.prototype.hasOwnProperty.call(this.tasks, taskName);
-	}
-
-	/**
-	 * Takes a list of tasks which should be executed from the available task list of the current builder
-	 *
-	 * @param {Array} tasksToRun List of tasks which should be executed
-	 * @returns {Promise} Returns promise chain with tasks
-	 */
-	build(tasksToRun) {
-		const allTasks = this.taskExecutionOrder.filter((taskName) => {
-			// There might be a numeric suffix in case a custom task is configured multiple times.
-			// The suffix needs to be removed in order to check against the list of tasks to run.
-			//
-			// Note: The 'tasksToRun' parameter only allows to specify the custom task name
-			// (without suffix), so it executes either all or nothing.
-			// It's currently not possible to just execute some occurrences of a custom task.
-			// This would require a more robust contract to identify task executions
-			// (e.g. via an 'id' that can be assigned to a specific execution in the configuration).
-			const taskWithoutSuffixCounter = taskName.replace(/--\d+$/, "");
-			return this.hasTask(taskName) && tasksToRun.includes(taskWithoutSuffixCounter);
-		});
-
-		this.taskLog.addWork(allTasks.length);
-
-		return allTasks.reduce((taskChain, taskName) => {
-			const taskFunction = this.tasks[taskName];
-
-			if (typeof taskFunction === "function") {
-				taskChain = taskChain.then(this.wrapTask(taskName, taskFunction));
-			}
-
-			return taskChain;
-		}, Promise.resolve());
-	}
-
-	/**
-	 * Adds progress related functionality to task function.
-	 *
-	 * @private
-	 * @param {string} taskName Name of the task
-	 * @param {Function} taskFunction Function which executed the task
-	 * @returns {Function} Wrapped task function
-	 */
-	wrapTask(taskName, taskFunction) {
-		return () => {
-			this.taskLog.startWork(`Running task ${taskName}...`);
-			return taskFunction().then(() => this.taskLog.completeWork(1));
-		};
-	}
-
-	/**
-	 * Appends the list of 'excludes' to the list of 'patterns'. To harmonize both lists, the 'excludes'
-	 * are negated and the 'patternPrefix' is added to make them absolute.
-	 *
-	 * @private
-	 * @param {string[]} patterns
-	 *   List of absolute default patterns.
-	 * @param {string[]} excludes
-	 *   List of relative patterns to be excluded. Excludes with a leading "!" are meant to be re-included.
-	 * @param {string} patternPrefix
-	 *   Prefix to be added to the excludes to make them absolute. The prefix must have a leading and a
-	 *   trailing "/".
-	 */
-	enhancePatternWithExcludes(patterns, excludes, patternPrefix) {
-		excludes.forEach((exclude) => {
-			if (exclude.startsWith("!")) {
-				patterns.push(`${patternPrefix}${exclude.slice(1)}`);
-			} else {
-				patterns.push(`!${patternPrefix}${exclude}`);
-			}
-		});
-	}
-}
-
-module.exports = AbstractBuilder;