feat: Incremental Build

packages/builder/lib/processors/nonAsciiEscaper.js

@@ -83,8 +83,8 @@ async function nonAsciiEscaper({resources, options: {encoding}}) {
 		// only modify the resource's string if it was changed
 		if (escaped.modified) {
 			resource.setString(escaped.string);
+			return resource;
 		}
-		return resource;
 	}
 
 	return Promise.all(resources.map(processResource));

packages/builder/lib/processors/stringReplacer.js

@@ -23,7 +23,8 @@ export default function({resources, options: {pattern, replacement}}) {
 		const newContent = content.replaceAll(pattern, replacement);
 		if (content !== newContent) {
 			resource.setString(newContent);
+			return resource;
 		}
-		return resource;
+		// return resource;
 	}));
 }

packages/builder/lib/tasks/buildThemes.js

@@ -192,7 +192,7 @@ export default async function({
 	}
 
 	let processedResources;
-	const useWorkers = !!taskUtil;
+	const useWorkers = !process.env.UI5_CLI_NO_WORKERS && !!taskUtil;
 	if (useWorkers) {
 		const threadMessageHandler = new FsMainThreadInterface(fsInterface(combo));
 

packages/builder/lib/tasks/escapeNonAsciiCharacters.js

@@ -14,17 +14,24 @@ import nonAsciiEscaper from "../processors/nonAsciiEscaper.js";
  *
  * @param {object} parameters Parameters
  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
+ * @param {string[]} [parameters.changedProjectResourcePaths] Set of changed resource paths within the project.
+ * This is only set if a cache is used and changes have been detected.
  * @param {object} parameters.options Options
  * @param {string} parameters.options.pattern Glob pattern to locate the files to be processed
  * @param {string} parameters.options.encoding source file encoding either "UTF-8" or "ISO-8859-1"
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
-export default async function({workspace, options: {pattern, encoding}}) {
+export default async function({workspace, changedProjectResourcePaths, options: {pattern, encoding}}) {
 	if (!encoding) {
 		throw new Error("[escapeNonAsciiCharacters] Mandatory option 'encoding' not provided");
 	}
 
-	const allResources = await workspace.byGlob(pattern);
+	let allResources;
+	if (changedProjectResourcePaths) {
+		allResources = await Promise.all(changedProjectResourcePaths.map((resource) => workspace.byPath(resource)));
+	} else {
+		allResources = await workspace.byGlob(pattern);
+	}
 
 	const processedResources = await nonAsciiEscaper({
 		resources: allResources,
@@ -33,5 +40,5 @@ export default async function({workspace, options: {pattern, encoding}}) {
 		}
 	});
 
-	await Promise.all(processedResources.map((resource) => workspace.write(resource)));
+	await Promise.all(processedResources.map((resource) => resource && workspace.write(resource)));
 }

packages/builder/lib/tasks/minify.js

@@ -16,6 +16,8 @@ import fsInterface from "@ui5/fs/fsInterface";
  * @param {object} parameters Parameters
  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
  * @param {@ui5/project/build/helpers/TaskUtil|object} [parameters.taskUtil] TaskUtil
+ * @param {string[]} [parameters.changedProjectResourcePaths] Set of changed resource paths within the project.
+ * This is only set if a cache is used and changes have been detected.
  * @param {object} parameters.options Options
  * @param {string} parameters.options.pattern Pattern to locate the files to be processed
  * @param {boolean} [parameters.options.omitSourceMapResources=false] Whether source map resources shall
@@ -26,17 +28,26 @@ import fsInterface from "@ui5/fs/fsInterface";
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
 export default async function({
-	workspace, taskUtil, options: {pattern, omitSourceMapResources = false, useInputSourceMaps = true
-	}}) {
-	const resources = await workspace.byGlob(pattern);
+	workspace, taskUtil, changedProjectResourcePaths,
+	options: {pattern, omitSourceMapResources = false, useInputSourceMaps = true}
+}) {
+	let resources;
+	if (changedProjectResourcePaths) {
+		resources = await Promise.all(changedProjectResourcePaths.map((resource) => workspace.byPath(resource)));
+	} else {
+		resources = await workspace.byGlob(pattern);
+	}
+	if (resources.length === 0) {
+		return;
+	}
 	const processedResources = await minifier({
 		resources,
 		fs: fsInterface(workspace),
 		taskUtil,
 		options: {
 			addSourceMappingUrl: !omitSourceMapResources,
 			readSourceMappingUrl: !!useInputSourceMaps,
-			useWorkers: !!taskUtil,
+			useWorkers: !process.env.UI5_CLI_NO_WORKERS && !!taskUtil,
 		}
 	});
 

packages/builder/lib/tasks/replaceBuildtime.js

@@ -28,26 +28,30 @@ function getTimestamp() {
  *
  * @param {object} parameters Parameters
  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
+ * @param {string[]} [parameters.changedProjectResourcePaths] Set of changed resource paths within the project.
+ * This is only set if a cache is used and changes have been detected.
  * @param {object} parameters.options Options
  * @param {string} parameters.options.pattern Pattern to locate the files to be processed
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
-export default function({workspace, options: {pattern}}) {
+export default async function({workspace, changedProjectResourcePaths, options: {pattern}}) {
+	let resources;
+	if (changedProjectResourcePaths) {
+		resources = await Promise.all(changedProjectResourcePaths.map((resource) => workspace.byPath(resource)));
+	} else {
+		resources = await workspace.byGlob(pattern);
+	}
 	const timestamp = getTimestamp();
-
-	return workspace.byGlob(pattern)
-		.then((processedResources) => {
-			return stringReplacer({
-				resources: processedResources,
-				options: {
-					pattern: "${buildtime}",
-					replacement: timestamp
-				}
-			});
-		})
-		.then((processedResources) => {
-			return Promise.all(processedResources.map((resource) => {
-				return workspace.write(resource);
-			}));
-		});
+	const processedResources = await stringReplacer({
+		resources,
+		options: {
+			pattern: "${buildtime}",
+			replacement: timestamp
+		}
+	});
+	return Promise.all(processedResources.map((resource) => {
+		if (resource) {
+			return workspace.write(resource);
+		}
+	}));
 }

packages/builder/lib/tasks/replaceCopyright.js

@@ -24,32 +24,38 @@ import stringReplacer from "../processors/stringReplacer.js";
  *
  * @param {object} parameters Parameters
  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
+ * @param {string[]} [parameters.changedProjectResourcePaths] Set of changed resource paths within the project.
+ * This is only set if a cache is used and changes have been detected.
  * @param {object} parameters.options Options
  * @param {string} parameters.options.copyright Replacement copyright
  * @param {string} parameters.options.pattern Pattern to locate the files to be processed
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
-export default function({workspace, options: {copyright, pattern}}) {
+export default async function({workspace, changedProjectResourcePaths, options: {copyright, pattern}}) {
 	if (!copyright) {
-		return Promise.resolve();
+		return;
 	}
 
 	// Replace optional placeholder ${currentYear} with the current year
 	copyright = copyright.replace(/(?:\$\{currentYear\})/, new Date().getFullYear());
 
-	return workspace.byGlob(pattern)
-		.then((processedResources) => {
-			return stringReplacer({
-				resources: processedResources,
-				options: {
-					pattern: /(?:\$\{copyright\}|@copyright@)/g,
-					replacement: copyright
-				}
-			});
-		})
-		.then((processedResources) => {
-			return Promise.all(processedResources.map((resource) => {
-				return workspace.write(resource);
-			}));
-		});
+	let resources;
+	if (changedProjectResourcePaths) {
+		resources = await Promise.all(changedProjectResourcePaths.map((resource) => workspace.byPath(resource)));
+	} else {
+		resources = await workspace.byGlob(pattern);
+	}
+
+	const processedResources = await stringReplacer({
+		resources,
+		options: {
+			pattern: /(?:\$\{copyright\}|@copyright@)/g,
+			replacement: copyright
+		}
+	});
+	return Promise.all(processedResources.map((resource) => {
+		if (resource) {
+			return workspace.write(resource);
+		}
+	}));
 }

packages/builder/lib/tasks/replaceVersion.js

@@ -14,25 +14,30 @@ import stringReplacer from "../processors/stringReplacer.js";
  *
  * @param {object} parameters Parameters
  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
+ * @param {string[]} [parameters.changedProjectResourcePaths] Set of changed resource paths within the project.
+ * This is only set if a cache is used and changes have been detected.
  * @param {object} parameters.options Options
  * @param {string} parameters.options.pattern Pattern to locate the files to be processed
  * @param {string} parameters.options.version Replacement version
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
-export default function({workspace, options: {pattern, version}}) {
-	return workspace.byGlob(pattern)
-		.then((allResources) => {
-			return stringReplacer({
-				resources: allResources,
-				options: {
-					pattern: /\$\{(?:project\.)?version\}/g,
-					replacement: version
-				}
-			});
-		})
-		.then((processedResources) => {
-			return Promise.all(processedResources.map((resource) => {
-				return workspace.write(resource);
-			}));
-		});
+export default async function({workspace, changedProjectResourcePaths, options: {pattern, version}}) {
+	let resources;
+	if (changedProjectResourcePaths) {
+		resources = await Promise.all(changedProjectResourcePaths.map((resource) => workspace.byPath(resource)));
+	} else {
+		resources = await workspace.byGlob(pattern);
+	}
+	const processedResources = await stringReplacer({
+		resources,
+		options: {
+			pattern: /\$\{(?:project\.)?version\}/g,
+			replacement: version
+		}
+	});
+	await Promise.all(processedResources.map((resource) => {
+		if (resource) {
+			return workspace.write(resource);
+		}
+	}));
 }

packages/builder/test/utils/fshelper.js

@@ -11,8 +11,8 @@ export async function readFileContent(filePath) {
 }
 
 export async function directoryDeepEqual(t, destPath, expectedPath) {
-	const dest = await readdir(destPath, {recursive: true});
-	const expected = await readdir(expectedPath, {recursive: true});
+	const dest = (await readdir(destPath, {recursive: true})).sort();
+	const expected = (await readdir(expectedPath, {recursive: true})).sort();
 	t.deepEqual(dest, expected);
 }
 

packages/cli/lib/cli/commands/build.js

@@ -1,4 +1,5 @@
 import baseMiddleware from "../middlewares/base.js";
+import path from "node:path";
 
 const build = {
 	command: "build",
@@ -173,6 +174,7 @@ async function handleBuild(argv) {
 	const buildSettings = graph.getRoot().getBuilderSettings() || {};
 	await graph.build({
 		graph,
+		cacheDir: path.join(graph.getRoot().getRootPath(), ".ui5-cache"),
 		destPath: argv.dest,
 		cleanDest: argv["clean-dest"],
 		createBuildManifest: argv["create-build-manifest"],

packages/fs/lib/MonitoredReader.js

@@ -0,0 +1,49 @@
+import AbstractReader from "./AbstractReader.js";
+
+export default class MonitoredReader extends AbstractReader {
+	#reader;
+	#sealed = false;
+	#paths = [];
+	#patterns = [];
+
+	constructor(reader) {
+		super(reader.getName());
+		this.#reader = reader;
+	}
+
+	getResourceRequests() {
+		this.#sealed = true;
+		return {
+			paths: this.#paths,
+			patterns: this.#patterns,
+		};
+	}
+
+	async _byGlob(virPattern, options, trace) {
+		if (this.#sealed) {
+			throw new Error(`Unexpected read operation after reader has been sealed`);
+		}
+		if (this.#reader.resolvePattern) {
+			const resolvedPattern = this.#reader.resolvePattern(virPattern);
+			this.#patterns.push(resolvedPattern);
+		} else {
+			this.#patterns.push(virPattern);
+		}
+		return await this.#reader._byGlob(virPattern, options, trace);
+	}
+
+	async _byPath(virPath, options, trace) {
+		if (this.#sealed) {
+			throw new Error(`Unexpected read operation after reader has been sealed`);
+		}
+		if (this.#reader.resolvePath) {
+			const resolvedPath = this.#reader.resolvePath(virPath);
+			if (resolvedPath) {
+				this.#paths.push(resolvedPath);
+			}
+		} else {
+			this.#paths.push(virPath);
+		}
+		return await this.#reader._byPath(virPath, options, trace);
+	}
+}

packages/fs/lib/MonitoredReaderWriter.js

@@ -0,0 +1,53 @@
+import AbstractReaderWriter from "./AbstractReaderWriter.js";
+
+export default class MonitoredReaderWriter extends AbstractReaderWriter {
+	#readerWriter;
+	#sealed = false;
+	#paths = new Set();
+	#patterns = new Set();
+
+	constructor(readerWriter) {
+		super(readerWriter.getName());
+		this.#readerWriter = readerWriter;
+	}
+
+	getResourceRequests() {
+		this.#sealed = true;
+		return {
+			paths: this.#paths,
+			patterns: this.#patterns,
+		};
+	}
+
+	async _byGlob(virPattern, options, trace) {
+		if (this.#sealed) {
+			throw new Error(`Unexpected read operation after reader has been sealed`);
+		}
+		if (this.#readerWriter.resolvePattern) {
+			const resolvedPattern = this.#readerWriter.resolvePattern(virPattern);
+			this.#patterns.add(resolvedPattern);
+		} else {
+			this.#patterns.add(virPattern);
+		}
+		return await this.#readerWriter._byGlob(virPattern, options, trace);
+	}
+
+	async _byPath(virPath, options, trace) {
+		if (this.#sealed) {
+			throw new Error(`Unexpected read operation after reader has been sealed`);
+		}
+		if (this.#readerWriter.resolvePath) {
+			const resolvedPath = this.#readerWriter.resolvePath(virPath);
+			if (resolvedPath) {
+				this.#paths.add(resolvedPath);
+			}
+		} else {
+			this.#paths.add(virPath);
+		}
+		return await this.#readerWriter._byPath(virPath, options, trace);
+	}
+
+	async _write(resource, options) {
+		return this.#readerWriter.write(resource, options);
+	}
+}

packages/fs/lib/ReaderCollectionPrioritized.js

@@ -68,7 +68,7 @@ class ReaderCollectionPrioritized extends AbstractReader {
 	 * @returns {Promise<@ui5/fs/Resource|null>}
 	 *   Promise resolving to a single resource or <code>null</code> if no resource is found
 	 */
-	_byPath(virPath, options, trace) {
+	async _byPath(virPath, options, trace) {
 		const that = this;
 		const byPath = (i) => {
 			if (i > this._readers.length - 1) {