@ui5/builder 3.0.8 → 3.1.0

package/CHANGELOG.md

@@ -2,10 +2,26 @@
 All notable changes to this project will be documented in this file.  
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-A list of unreleased changes can be found [here](https://github.com/SAP/ui5-builder/compare/v3.0.8...HEAD).
+A list of unreleased changes can be found [here](https://github.com/SAP/ui5-builder/compare/v3.1.0...HEAD).
+
+<a name="v3.1.0"></a>
+## [v3.1.0] - 2023-10-11
+### Bug Fixes
+- **bundle/Builder:** Add missing 'names' attribute to generated source maps [`57e0e50`](https://github.com/SAP/ui5-builder/commit/57e0e5047638a9a704a696b8af7780fbbceefbc4)
+
+### Features
+- Validate apiVersion property in Library.init ([#943](https://github.com/SAP/ui5-builder/issues/943)) [`52bf258`](https://github.com/SAP/ui5-builder/commit/52bf25842a59c3fa1ddbe71b482b232e18b55288)
+- **Minifier:** Support input source maps ([#780](https://github.com/SAP/ui5-builder/issues/780)) [`67ecb27`](https://github.com/SAP/ui5-builder/commit/67ecb27e44a2d84e6b2203f31049220dcbcd41f0)
+
+### Reverts
+- [INTERNAL] Azure Pipelines: Switch back to Node 20.5.x
+
+
+<a name="v3.0.9"></a>
+## [v3.0.9] - 2023-07-26
 
 <a name="v3.0.8"></a>
-## [v3.0.8] - 2023-07-18
+## [v3.0.8] - 2023-07-19
 ### Bug Fixes
 - Revert "[INTERNAL] Remove implicit dependencies concept ([#913](https://github.com/SAP/ui5-builder/issues/913))" [`1043714`](https://github.com/SAP/ui5-builder/commit/1043714e3b952a8280f1ff7909f79db3b750eb0c)
 - **generateJsdoc:** Also process resources created by preceeding tasks [`04447bd`](https://github.com/SAP/ui5-builder/commit/04447bdec28b8bf18c24bd53e3fe8be9bdeed6c2)
@@ -816,6 +832,8 @@ to load the custom bundle file instead.
 
 ### Features
 - Add ability to configure component preloads and custom bundles [`2241e5f`](https://github.com/SAP/ui5-builder/commit/2241e5ff98fd95f1f80cc74959655ae7a9c660e7)
+[v3.1.0]: https://github.com/SAP/ui5-builder/compare/v3.0.9...v3.1.0
+[v3.0.9]: https://github.com/SAP/ui5-builder/compare/v3.0.8...v3.0.9
 [v3.0.8]: https://github.com/SAP/ui5-builder/compare/v3.0.7...v3.0.8
 [v3.0.7]: https://github.com/SAP/ui5-builder/compare/v3.0.6...v3.0.7
 [v3.0.6]: https://github.com/SAP/ui5-builder/compare/v3.0.5...v3.0.6

package/lib/lbt/analyzer/analyzeLibraryJS.js

@@ -61,6 +61,9 @@ async function analyze(resource) {
 						libInfo.elements = getStringArray(value, true);
 					} else if ( ["designtime", "dependencies", "extensions", "name", "version"].includes(key) ) {
 						// do nothing, for all other supported properties
+					} else if ( key === "apiVersion" &&
+						(value.type === Syntax.Literal && typeof value.value === "number") ) {
+						// just a validation
 					} else {
 						log.error(
 							"Unexpected property '" + key +

package/lib/lbt/bundle/Builder.js

@@ -18,7 +18,7 @@ import BundleWriter from "./BundleWriter.js";
 import {getLogger} from "@ui5/logger";
 const log = getLogger("lbt:bundle:Builder");
 
-const sourceMappingUrlPattern = /\/\/# sourceMappingURL=(.+)\s*$/;
+const sourceMappingUrlPattern = /\/\/# sourceMappingURL=(\S+)\s*$/;
 const httpPattern = /^https?:\/\//i;
 const xmlHtmlPrePattern = /<(?:\w+:)?pre\b/;
 
@@ -332,11 +332,18 @@ class BundleBuilder {
 			throw new Error("No source map provided");
 		}
 
+		// Reminder on the structure of line-segments in the map:
+		// [generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex]
 		if (map.mappings.startsWith(";")) {
 			// If first line is not already mapped (typical for comments or parentheses), add a mapping to
 			// make sure that dev-tools (especially Chrome's) don't choose the end of the preceding module
 			// when the user tries to set a breakpoint from the bundle file
 			map.mappings = "AAAA" + map.mappings;
+		} else if (this.outW.columnOffset === 0 && !map.mappings.startsWith("A")) {
+			// If first column of the first line is not already mapped, add a mapping for the same reason as above.
+			// This is typical for transpiled code, where there is a bunch of generated code at the beginning that
+			// can't be mapped to the original source
+			map.mappings = "AAAA," + map.mappings;
 		}
 
 		map.sourceRoot = path.posix.relative(
@@ -592,9 +599,7 @@ class BundleBuilder {
 				`Attempting to find a source map resource based on the module's path: ${sourceMapFileCandidate}`);
 			try {
 				const sourceMapResource = await this.pool.findResource(sourceMapFileCandidate);
-				if (sourceMapResource) {
-					moduleSourceMap = (await sourceMapResource.buffer()).toString();
-				}
+				moduleSourceMap = (await sourceMapResource.buffer()).toString();
 			} catch (e) {
 				// No input source map
 				log.silly(`Could not find a source map for module ${moduleName}: ${e.message}`);
@@ -772,6 +777,7 @@ async function transform(changes, moduleContent, moduleSourceMap) {
 function createTransientSourceMap({moduleName, moduleContent, includeContent = false}) {
 	const sourceMap = {
 		version: 3,
+		names: [],
 		sources: [moduleName],
 		// TODO: check whether moduleContent.match() with \n is better w.r.t performance/memory usage
 		mappings: encodeMappings(moduleContent.split("\n").map((line, i) => {

package/lib/processors/minifier.js

@@ -1,5 +1,6 @@
 import {fileURLToPath} from "node:url";
 import posixPath from "node:path/posix";
+import {promisify} from "node:util";
 import os from "node:os";
 import workerpool from "workerpool";
 import Resource from "@ui5/fs/Resource";
@@ -13,6 +14,9 @@ const MAX_WORKERS = 4;
 const osCpus = os.cpus().length || 1;
 const maxWorkers = Math.max(Math.min(osCpus - 1, MAX_WORKERS), MIN_WORKERS);
 
+const sourceMappingUrlPattern = /\/\/# sourceMappingURL=(\S+)\s*$/;
+const httpPattern = /^https?:\/\//i;
+
 // Shared workerpool across all executions until the taskUtil cleanup is triggered
 let pool;
 
@@ -38,6 +42,63 @@ async function minifyInWorker(options, taskUtil) {
 	return getPool(taskUtil).exec("execMinification", [options]);
 }
 
+async function extractAndRemoveSourceMappingUrl(resource) {
+	const resourceContent = await resource.getString();
+	const resourcePath = resource.getPath();
+	const sourceMappingUrlMatch = resourceContent.match(sourceMappingUrlPattern);
+	if (sourceMappingUrlMatch) {
+		const sourceMappingUrl = sourceMappingUrlMatch[1];
+		if (log.isLevelEnabled("silly")) {
+			log.silly(`Found source map reference in content of resource ${resourcePath}: ${sourceMappingUrl}`);
+		}
+
+		// Strip sourceMappingURL from the resource to be minified
+		// It is not required anymore and will be replaced for in the minified resource
+		// and its debug variant anyways
+		resource.setString(resourceContent.replace(sourceMappingUrlPattern, ""));
+		return sourceMappingUrl;
+	}
+	return null;
+}
+
+async function getSourceMapFromUrl({sourceMappingUrl, resourcePath, readFile}) {
+	// =======================================================================
+	// This code is almost identical to code located in lbt/bundle/Builder.js
+	// Please try to update both places when making changes
+	// =======================================================================
+	if (sourceMappingUrl.startsWith("data:")) {
+		// Data-URI indicates an inline source map
+		const expectedTypeAndEncoding = "data:application/json;charset=utf-8;base64,";
+		if (sourceMappingUrl.startsWith(expectedTypeAndEncoding)) {
+			const base64Content = sourceMappingUrl.slice(expectedTypeAndEncoding.length);
+			// Create a resource with a path suggesting it's the source map for the resource
+			// (which it is but inlined)
+			return Buffer.from(base64Content, "base64").toString();
+		} else {
+			log.warn(
+				`Source map reference in resource ${resourcePath} is a data URI but has an unexpected` +
+				`encoding: ${sourceMappingUrl}. Expected it to start with ` +
+				`"data:application/json;charset=utf-8;base64,"`);
+		}
+	} else if (httpPattern.test(sourceMappingUrl)) {
+		log.warn(`Source map reference in resource ${resourcePath} is an absolute URL. ` +
+			`Currently, only relative URLs are supported.`);
+	} else if (posixPath.isAbsolute(sourceMappingUrl)) {
+		log.warn(`Source map reference in resource ${resourcePath} is an absolute path. ` +
+			`Currently, only relative paths are supported.`);
+	} else {
+		const sourceMapPath = posixPath.join(posixPath.dirname(resourcePath), sourceMappingUrl);
+
+		try {
+			const sourceMapContent = await readFile(sourceMapPath);
+			return sourceMapContent.toString();
+		} catch (e) {
+			// No input source map
+			log.warn(`Unable to read source map for resource ${resourcePath}: ${e.message}`);
+		}
+	}
+}
+
 /**
  * @public
  * @module @ui5/builder/processors/minifier
@@ -62,9 +123,16 @@ async function minifyInWorker(options, taskUtil) {
  *
  * @param {object} parameters Parameters
  * @param {@ui5/fs/Resource[]} parameters.resources List of resources to be processed
+ * @param {fs|module:@ui5/fs/fsInterface} parameters.fs Node fs or custom
+ *    [fs interface]{@link module:@ui5/fs/fsInterface}. Required when setting "readSourceMappingUrl" to true
  * @param {@ui5/builder/tasks/TaskUtil|object} [parameters.taskUtil] TaskUtil instance.
  *    Required when using the <code>useWorkers</code> option
  * @param {object} [parameters.options] Options
+ * @param {boolean} [parameters.options.readSourceMappingUrl=false]
+ *   Whether to make use of any existing source maps referenced in the resources to be minified. Use this option to
+ *   preserve references to the original source files, such as TypeScript files, in the generated source map.<br>
+ *   If a resource has been modified by a previous task, any existing source map will be ignored regardless of this
+ *    setting. This is to ensure that no inconsistent source maps are used. Check the verbose log for details.
  * @param {boolean} [parameters.options.addSourceMappingUrl=true]
  *   Whether to add a sourceMappingURL reference to the end of the minified resource
  * @param {boolean} [parameters.options.useWorkers=false]
@@ -72,8 +140,14 @@ async function minifyInWorker(options, taskUtil) {
  * @returns {Promise<module:@ui5/builder/processors/minifier~MinifierResult[]>}
  *   Promise resolving with object of resource, dbgResource and sourceMap
  */
-export default async function({resources, taskUtil, options: {addSourceMappingUrl = true, useWorkers = false} = {}}) {
+export default async function({
+	resources, fs, taskUtil, options: {readSourceMappingUrl = false, addSourceMappingUrl = true, useWorkers = false
+	} = {}}) {
 	let minify;
+	if (readSourceMappingUrl && !fs) {
+		throw new Error(`Option 'readSourceMappingUrl' requires parameter 'fs' to be provided`);
+	}
+
 	if (useWorkers) {
 		if (!taskUtil) {
 			// TaskUtil is required for worker support
@@ -86,12 +160,11 @@ export default async function({resources, taskUtil, options: {addSourceMappingUr
 	}
 
 	return Promise.all(resources.map(async (resource) => {
-		const dbgPath = resource.getPath().replace(debugFileRegex, "-dbg$1");
-		const dbgResource = await resource.clone();
-		dbgResource.setPath(dbgPath);
+		const resourcePath = resource.getPath();
+		const dbgPath = resourcePath.replace(debugFileRegex, "-dbg$1");
+		const dbgFilename = posixPath.basename(dbgPath);
 
 		const filename = posixPath.basename(resource.getPath());
-		const code = await resource.getString();
 
 		const sourceMapOptions = {
 			filename
@@ -99,7 +172,81 @@ export default async function({resources, taskUtil, options: {addSourceMappingUr
 		if (addSourceMappingUrl) {
 			sourceMapOptions.url = filename + ".map";
 		}
-		const dbgFilename = posixPath.basename(dbgPath);
+
+		// Remember contentModified flag before making changes to the resource via setString
+		const resourceContentModified = resource.getSourceMetadata()?.contentModified;
+
+		// In any case: Extract *and remove* source map reference from resource before cloning it
+		const sourceMappingUrl = await extractAndRemoveSourceMappingUrl(resource);
+
+		const code = await resource.getString();
+		// Create debug variant based off the original resource before minification
+		const dbgResource = await resource.clone();
+		dbgResource.setPath(dbgPath);
+
+		let dbgSourceMapResource;
+		if (sourceMappingUrl) {
+			if (resourceContentModified) {
+				log.verbose(
+					`Source map found in resource will be ignored because the resource has been ` +
+					`modified in a previous task: ${resourcePath}`);
+			} else if (readSourceMappingUrl) {
+				// Try to find a source map reference in the to-be-minified resource
+				// If we find one, provide it to terser as an input source map and keep using it for the
+				// debug variant of the resource
+				const sourceMapContent = await getSourceMapFromUrl({
+					sourceMappingUrl,
+					resourcePath,
+					readFile: promisify(fs.readFile)
+				});
+
+				if (sourceMapContent) {
+					const sourceMapJson = JSON.parse(sourceMapContent);
+
+					if (sourceMapJson.sections) {
+						// TODO 4.0
+						// Module "@jridgewell/trace-mapping" (used by Terser) can't handle index map sections lacking
+						// a "names" array. Since this is a common occurrence for UI5 Tooling bundles, we search for
+						// such cases here and fix them until https://github.com/jridgewell/trace-mapping/pull/29 is
+						// resolved and Terser upgraded the dependency
+
+						// Create a dedicated clone before modifying the source map as to not alter the debug source map
+						const clonedSourceMapJson = JSON.parse(sourceMapContent);
+						clonedSourceMapJson.sections.forEach(({map}) => {
+							if (!map.names) {
+								// Add missing names array
+								map.names = [];
+							}
+						});
+						// Use modified source map as input source map
+						sourceMapOptions.content = JSON.stringify(clonedSourceMapJson);
+					} else {
+						// Provide source map to terser as "input source map"
+						sourceMapOptions.content = sourceMapContent;
+					}
+
+					// Use the original source map for the debug variant of the resource
+					// First update the file reference within the source map
+					sourceMapJson.file = dbgFilename;
+
+					// Then create a new resource
+					dbgSourceMapResource = new Resource({
+						string: JSON.stringify(sourceMapJson),
+						path: dbgPath + ".map"
+					});
+					// And reference the resource in the debug resource
+					dbgResource.setString(code + `//# sourceMappingURL=${dbgFilename}.map\n`);
+				}
+			} else {
+				// If the original resource content was unmodified and the input source map was not parsed,
+				// re-add the original source map reference to the debug variant
+				if (!sourceMappingUrl.startsWith("data:") && !sourceMappingUrl.endsWith(filename + ".map")) {
+					// Do not re-add inline source maps as well as references to the source map of
+					// the minified resource
+					dbgResource.setString(code + `//# sourceMappingURL=${sourceMappingUrl}\n`);
+				}
+			}
+		}
 
 		const result = await minify({
 			filename,
@@ -112,6 +259,9 @@ export default async function({resources, taskUtil, options: {addSourceMappingUr
 			path: resource.getPath() + ".map",
 			string: result.map
 		});
-		return {resource, dbgResource, sourceMapResource};
+		return {resource, dbgResource, sourceMapResource, dbgSourceMapResource};
 	}));
 }
+
+export const __localFunctions__ = (process.env.NODE_ENV === "test") ?
+	{getSourceMapFromUrl} : undefined;

package/lib/processors/minifierWorker.js

@@ -62,7 +62,9 @@ export default async function execMinification({
 		// Note: err.filename contains the debug-name
 		throw new Error(
 			`Minification failed with error: ${err.message} in file ${filename} ` +
-			`(line ${err.line}, col ${err.col}, pos ${err.pos})`);
+			`(line ${err.line}, col ${err.col}, pos ${err.pos})`, {
+				cause: err
+			});
 	}
 }
 

package/lib/processors/themeBuilderWorker.js

@@ -0,0 +1,278 @@
+import workerpool from "workerpool";
+import themeBuilder from "./themeBuilder.js";
+import {createResource} from "@ui5/fs/resourceFactory";
+import {Buffer} from "node:buffer";
+
+/**
+ * Task to build library themes.
+ *
+ * @private
+ * @function default
+ * @static
+ *
+ * @param {object} parameters Parameters
+ * @param {MessagePort} parameters.fsInterfacePort
+ * @param {object[]} parameters.themeResources Input array of Uint8Array transferable objects
+ * 	that are the less sources to build upon. By nature those are @ui5/fs/Resource.
+ * @param {object} parameters.options Less compiler options
+ * @returns {Promise<object[]>} Resulting array of Uint8Array transferable objects
+ */
+export default async function execThemeBuild({
+	fsInterfacePort,
+	themeResources = [],
+	options = {}
+}) {
+	const fsThemeResources = deserializeResources(themeResources);
+	const fsReader = new FsWorkerThreadInterface(fsInterfacePort);
+
+	const result = await themeBuilder({
+		resources: fsThemeResources,
+		fs: fsReader,
+		options
+	});
+
+	return serializeResources(result);
+}
+
+/**
+ * Casts @ui5/fs/Resource-s into an Uint8Array transferable object
+ *
+ * @param {@ui5/fs/Resource[]} resourceCollection
+ * @returns {Promise<object[]>}
+ */
+export async function serializeResources(resourceCollection) {
+	return Promise.all(
+		resourceCollection.map(async (res) => ({
+			buffer: await res.getBuffer(),
+			path: res.getPath()
+		}))
+	);
+}
+
+/**
+ * Casts Uint8Array into @ui5/fs/Resource-s transferable object
+ *
+ * @param {Promise<object[]>} resources
+ * @returns {@ui5/fs/Resource[]}
+ */
+export function deserializeResources(resources) {
+	return resources.map((res) => {
+		// res.buffer is an Uint8Array object and needs to be cast
+		// to a Buffer in order to be read correctly.
+		return createResource({path: res.path, buffer: Buffer.from(res.buffer)});
+	});
+}
+
+/**
+ * "@ui5/fs/fsInterface" like class that uses internally
+ * "@ui5/fs/fsInterface", implements its methods, and
+ * sends the results to a MessagePort.
+ *
+ * Used in the main thread in a combination with FsWorkerThreadInterface.
+ */
+export class FsMainThreadInterface {
+	#comPorts = new Set();
+	#fsInterfaceReader = null;
+	#cache = Object.create(null);
+
+	/**
+	 * Constructor
+	 *
+	 * @param {@ui5/fs/fsInterface} fsInterfaceReader Reader for the Resources
+	 */
+	constructor(fsInterfaceReader) {
+		if (!fsInterfaceReader) {
+			throw new Error("fsInterfaceReader is mandatory argument");
+		}
+
+		this.#fsInterfaceReader = fsInterfaceReader;
+	}
+
+	/**
+	 * Adds MessagePort and starts listening for requests on it.
+	 *
+	 * @param {MessagePort} comPort port1 from a {code}MessageChannel{/code}
+	 */
+	startCommunication(comPort) {
+		if (!comPort) {
+			throw new Error("Communication channel is mandatory argument");
+		}
+
+		this.#comPorts.add(comPort);
+		comPort.on("message", (e) => this.#onMessage(e, comPort));
+		comPort.on("close", () => comPort.close());
+	}
+
+	/**
+	 * Ends MessagePort communication.
+	 *
+	 * @param {MessagePort} comPort port1 to remove from handling.
+	 */
+	endCommunication(comPort) {
+		comPort.close();
+		this.#comPorts.delete(comPort);
+	}
+
+	/**
+	 * Destroys the FsMainThreadInterface
+	 */
+	cleanup() {
+		this.#comPorts.forEach((comPort) => comPort.close());
+		this.#cache = null;
+		this.#fsInterfaceReader = null;
+	}
+
+	/**
+	 * Handles messages from the MessagePort
+	 *
+	 * @param {object} e data to construct the request
+	 * @param {string} e.action Action to perform. Corresponds to the names of
+	 * 	the public methods of "@ui5/fs/fsInterface"
+	 * @param {string} e.fsPath Path of the Resource
+	 * @param {object} e.options Options for "readFile" action
+	 * @param {MessagePort} comPort The communication channel
+	 */
+	#onMessage(e, comPort) {
+		switch (e.action) {
+		case "readFile":
+			this.#doRequest(comPort, {action: "readFile", fsPath: e.fsPath, options: e.options});
+			break;
+		case "stat":
+			this.#doRequest(comPort, {action: "stat", fsPath: e.fsPath});
+			break;
+		}
+	}
+
+	/**
+	 * Requests a Resource from the "@ui5/fs/fsInterface" and sends it to the worker threads
+	 * via postMessage.
+	 *
+	 * @param {MessagePort} comPort The communication channel
+	 * @param {object} parameters
+	 * @param {string} parameters.action Action to perform. Corresponds to the names of
+	 * 	the public methods of "@ui5/fs/fsInterface" and triggers this method of the
+	 *	"@ui5/fs/fsInterface" instance.
+	 * @param {string} parameters.fsPath Path of the Resource
+	 * @param {object} parameters.options Options for "readFile" action
+	 */
+	async #doRequest(comPort, {action, fsPath, options}) {
+		const cacheKey = `${fsPath}-${action}`;
+		if (!this.#cache[cacheKey]) {
+			this.#cache[cacheKey] = new Promise((res) => {
+				if (action === "readFile") {
+					this.#fsInterfaceReader.readFile(fsPath, options, (error, result) => res({error, result}));
+				} else if (action === "stat") {
+					this.#fsInterfaceReader.stat(fsPath, (error, result) =>
+						// The Stat object has some special methods that sometimes cannot be serialized
+						// properly in the postMessage. In this scenario, we do not need those methods,
+						// but just to check whether stats has resolved to something.
+						res(JSON.parse(JSON.stringify({error, result})))
+					);
+				} else {
+					res({error: new Error(`Action "${action}" is not available.`), result: null});
+				}
+			});
+		}
+
+		const fromCache = await this.#cache[cacheKey];
+		comPort.postMessage({action, fsPath, ...fromCache});
+	}
+}
+
+/**
+ * "@ui5/fs/fsInterface" like class that uses internally
+ * "@ui5/fs/fsInterface", implements its methods, and
+ * requests resources via MessagePort.
+ *
+ * Used in the main thread in a combination with FsMainThreadInterface.
+ */
+export class FsWorkerThreadInterface {
+	#comPort = null;
+	#callbacks = [];
+	#cache = Object.create(null);
+
+	/**
+	 * Constructor
+	 *
+	 * @param {MessagePort} comPort Communication port
+	 */
+	constructor(comPort) {
+		if (!comPort) {
+			throw new Error("Communication port is mandatory argument");
+		}
+
+		this.#comPort = comPort;
+		comPort.on("message", this.#onMessage.bind(this));
+		comPort.on("close", this.#onClose.bind(this));
+	}
+
+	/**
+	 * Handles messages from MessagePort
+	 *
+	 * @param {object} e
+	 * @param {string} e.action Action to perform. Corresponds to the names of
+	 * 	the public methods of "@ui5/fs/fsInterface"
+	 * @param {string} e.fsPath Path of the Resource
+	 * @param {*} e.result Response from the "action".
+	 * @param {object} e.error Error from the "action".
+	 */
+	#onMessage(e) {
+		const cbObject = this.#callbacks.find((cb) => cb.action === e.action && cb.fsPath === e.fsPath);
+
+		if (cbObject) {
+			this.#cache[`${e.fsPath}-${e.action}`] = {error: e.error, result: e.result};
+			this.#callbacks.splice(this.#callbacks.indexOf(cbObject), 1);
+			cbObject.callback(e.error, e.result);
+		} else {
+			throw new Error("No callback found for this message! Possible hang for the thread!", e);
+		}
+	}
+
+	/**
+	 * End communication
+	 */
+	#onClose() {
+		this.#comPort.close();
+		this.#cache = null;
+	}
+
+	/**
+	 * Makes a request via the MessagePort
+	 *
+	 * @param {object} parameters
+	 * @param {string} parameters.action Action to perform. Corresponds to the names of
+	 * 	the public methods.
+	 * @param {string} parameters.fsPath Path of the Resource
+	 * @param {object} parameters.options Options for "readFile" action
+	 * @param {Function} callback Callback to call when the "action" is executed and ready.
+	 */
+	#doRequest({action, fsPath, options}, callback) {
+		const cacheKey = `${fsPath}-${action}`;
+
+		if (this.#cache[cacheKey]) {
+			const {result, error} = this.#cache[cacheKey];
+			callback(error, result);
+		} else {
+			this.#callbacks.push({action, fsPath, callback});
+			this.#comPort.postMessage({action, fsPath, options});
+		}
+	}
+
+	readFile(fsPath, options, callback) {
+		this.#doRequest({action: "readFile", fsPath, options}, callback);
+	}
+
+	stat(fsPath, callback) {
+		this.#doRequest({action: "stat", fsPath}, callback);
+	}
+}
+
+// Test execution via ava is never done on the main thread
+/* istanbul ignore else */
+if (!workerpool.isMainThread) {
+	// Script got loaded through workerpool
+	// => Create a worker and register public functions
+	workerpool.worker({
+		execThemeBuild
+	});
+}

package/lib/tasks/buildThemes.js

@@ -1,9 +1,44 @@
 import path from "node:path";
-import themeBuilder from "../processors/themeBuilder.js";
 import fsInterface from "@ui5/fs/fsInterface";
 import ReaderCollectionPrioritized from "@ui5/fs/ReaderCollectionPrioritized";
 import {getLogger} from "@ui5/logger";
 const log = getLogger("builder:tasks:buildThemes");
+import {fileURLToPath} from "node:url";
+import os from "node:os";
+import workerpool from "workerpool";
+import {deserializeResources, serializeResources, FsMainThreadInterface} from "../processors/themeBuilderWorker.js";
+
+let pool;
+
+function getPool(taskUtil) {
+	if (!pool) {
+		const MIN_WORKERS = 2;
+		const MAX_WORKERS = 4;
+		const osCpus = os.cpus().length || 1;
+		const maxWorkers = Math.max(Math.min(osCpus - 1, MAX_WORKERS), MIN_WORKERS);
+
+		log.verbose(`Creating workerpool with up to ${maxWorkers} workers (available CPU cores: ${osCpus})`);
+		const workerPath = fileURLToPath(new URL("../processors/themeBuilderWorker.js", import.meta.url));
+		pool = workerpool.pool(workerPath, {
+			workerType: "thread",
+			maxWorkers
+		});
+		taskUtil.registerCleanupTask(() => {
+			log.verbose(`Terminating workerpool`);
+			const poolToBeTerminated = pool;
+			pool = null;
+			poolToBeTerminated.terminate();
+		});
+	}
+	return pool;
+}
+
+async function buildThemeInWorker(taskUtil, options, transferList) {
+	const toTransfer = transferList ? {transfer: transferList} : undefined;
+
+	return getPool(taskUtil).exec("execThemeBuild", [options], toTransfer);
+}
+
 
 /**
  * @public
@@ -19,6 +54,8 @@ const log = getLogger("builder:tasks:buildThemes");
  * @param {object} parameters Parameters
  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
  * @param {@ui5/fs/AbstractReader} parameters.dependencies Reader or Collection to read dependency files
+ * @param {@ui5/builder/tasks/TaskUtil|object} [parameters.taskUtil] TaskUtil instance.
+ *    Required to run buildThemes in parallel execution mode.
  * @param {object} parameters.options Options
  * @param {string} parameters.options.projectName Project name
  * @param {string} parameters.options.inputPattern Search pattern for *.less files to be built
@@ -29,9 +66,10 @@ const log = getLogger("builder:tasks:buildThemes");
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
 export default async function({
-	workspace, dependencies,
+	workspace, dependencies, taskUtil,
 	options: {
-		projectName, inputPattern, librariesPattern, themesPattern, compress, cssVariables
+		projectName, inputPattern, librariesPattern, themesPattern, compress,
+		cssVariables
 	}
 }) {
 	const combo = new ReaderCollectionPrioritized({
@@ -41,7 +79,7 @@ export default async function({
 
 	compress = compress === undefined ? true : compress;
 
-	const pAllResources = workspace.byGlob(inputPattern);
+	const pThemeResources = workspace.byGlob(inputPattern);
 	let pAvailableLibraries;
 	let pAvailableThemes;
 	if (librariesPattern) {
@@ -78,7 +116,7 @@ export default async function({
 			});
 	}
 
-	let allResources = await pAllResources;
+	let themeResources = await pThemeResources;
 
 	const isAvailable = function(resource) {
 		let libraryAvailable = false;
@@ -128,17 +166,48 @@ export default async function({
 				log.verbose(`Available sap.ui.core themes: ${availableThemes.join(", ")}`);
 			}
 		}
-		allResources = allResources.filter(isAvailable);
+		themeResources = themeResources.filter(isAvailable);
 	}
 
-	const processedResources = await themeBuilder({
-		resources: allResources,
-		fs: fsInterface(combo),
-		options: {
-			compress,
-			cssVariables: !!cssVariables
-		}
-	});
+	let processedResources;
+	const useWorkers = !!taskUtil;
+	if (useWorkers) {
+		const threadMessageHandler = new FsMainThreadInterface(fsInterface(combo));
+
+		processedResources = await Promise.all(themeResources.map(async (themeRes) => {
+			const {port1, port2} = new MessageChannel();
+			threadMessageHandler.startCommunication(port1);
+
+			const result = await buildThemeInWorker(taskUtil, {
+				fsInterfacePort: port2,
+				themeResources: await serializeResources([themeRes]),
+				options: {
+					compress,
+					cssVariables: !!cssVariables,
+				},
+			}, [port2]);
+
+			threadMessageHandler.endCommunication(port1);
+
+			return result;
+		}))
+			.then((resources) => Array.prototype.concat.apply([], resources))
+			.then(deserializeResources);
+
+		threadMessageHandler.cleanup();
+	} else {
+		// Do not use workerpool
+		const themeBuilder = (await import("../processors/themeBuilder.js")).default;
+
+		processedResources = await themeBuilder({
+			resources: themeResources,
+			fs: fsInterface(combo),
+			options: {
+				compress,
+				cssVariables: !!cssVariables,
+			}
+		});
+	}
 
 	await Promise.all(processedResources.map((resource) => {
 		return workspace.write(resource);

package/lib/tasks/bundlers/utils/createModuleNameMapping.js

@@ -18,8 +18,8 @@ export default function({resources, taskUtil}) {
 	const moduleNameMapping = Object.create(null);
 	for (let i = resources.length - 1; i >= 0; i--) {
 		const resource = resources[i];
-		if (taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant)) {
-			const resourcePath = resource.getPath();
+		const resourcePath = resource.getPath();
+		if (resourcePath.endsWith(".js") && taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant)) {
 			const nonDbgPath = getNonDebugName(resourcePath);
 			if (!nonDbgPath) {
 				throw new Error(`Failed to resolve non-debug name for ${resourcePath}`);

package/lib/tasks/minify.js

@@ -1,4 +1,5 @@
 import minifier from "../processors/minifier.js";
+import fsInterface from "@ui5/fs/fsInterface";
 
 /**
  * @public
@@ -19,20 +20,29 @@ import minifier from "../processors/minifier.js";
  * @param {string} parameters.options.pattern Pattern to locate the files to be processed
  * @param {boolean} [parameters.options.omitSourceMapResources=false] Whether source map resources shall
  * 		be tagged as "OmitFromBuildResult" and no sourceMappingURL shall be added to the minified resource
+ * @param {boolean} [parameters.options.useInputSourceMaps=true] Whether to make use of any existing source
+ * 		maps referenced in the resources to be minified. Use this option to preserve reference to the original
+ * 		source files, such as TypeScript files, in the generated source map.
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
-export default async function({workspace, taskUtil, options: {pattern, omitSourceMapResources = false}}) {
+export default async function({
+	workspace, taskUtil, options: {pattern, omitSourceMapResources = false, useInputSourceMaps = true
+	}}) {
 	const resources = await workspace.byGlob(pattern);
 	const processedResources = await minifier({
 		resources,
+		fs: fsInterface(workspace),
 		taskUtil,
 		options: {
 			addSourceMappingUrl: !omitSourceMapResources,
+			readSourceMappingUrl: !!useInputSourceMaps,
 			useWorkers: !!taskUtil,
 		}
 	});
 
-	return Promise.all(processedResources.map(async ({resource, dbgResource, sourceMapResource}) => {
+	return Promise.all(processedResources.map(async ({
+		resource, dbgResource, sourceMapResource, dbgSourceMapResource
+	}) => {
 		if (taskUtil) {
 			taskUtil.setTag(resource, taskUtil.STANDARD_TAGS.HasDebugVariant);
 			taskUtil.setTag(dbgResource, taskUtil.STANDARD_TAGS.IsDebugVariant);
@@ -40,11 +50,18 @@ export default async function({workspace, taskUtil, options: {pattern, omitSourc
 			if (omitSourceMapResources) {
 				taskUtil.setTag(sourceMapResource, taskUtil.STANDARD_TAGS.OmitFromBuildResult);
 			}
+			if (dbgSourceMapResource) {
+				taskUtil.setTag(dbgSourceMapResource, taskUtil.STANDARD_TAGS.IsDebugVariant);
+				if (omitSourceMapResources) {
+					taskUtil.setTag(dbgSourceMapResource, taskUtil.STANDARD_TAGS.OmitFromBuildResult);
+				}
+			}
 		}
 		return Promise.all([
 			workspace.write(resource),
 			workspace.write(dbgResource),
-			workspace.write(sourceMapResource)
+			workspace.write(sourceMapResource),
+			dbgSourceMapResource && workspace.write(dbgSourceMapResource)
 		]);
 	}));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ui5/builder",
-	"version": "3.0.8",
+	"version": "3.1.0",
 	"description": "UI5 Tooling - Builder",
 	"author": {
 		"name": "SAP SE",
@@ -119,7 +119,7 @@
 	},
 	"dependencies": {
 		"@jridgewell/sourcemap-codec": "^1.4.15",
-		"@ui5/fs": "^3.0.4",
+		"@ui5/fs": "^3.0.5",
 		"@ui5/logger": "^3.0.0",
 		"cheerio": "1.0.0-rc.12",
 		"escape-unicode": "^0.2.0",
@@ -129,31 +129,33 @@
 		"jsdoc": "^4.0.2",
 		"less-openui5": "^0.11.6",
 		"pretty-data": "^0.40.0",
-		"rimraf": "^5.0.1",
+		"rimraf": "^5.0.5",
 		"semver": "^7.5.4",
-		"terser": "^5.19.0",
-		"workerpool": "^6.4.0",
-		"xml2js": "^0.6.0"
+		"terser": "^5.21.0",
+		"workerpool": "^6.5.0",
+		"xml2js": "^0.6.2"
 	},
 	"devDependencies": {
 		"@istanbuljs/esm-loader-hook": "^0.2.0",
-		"@ui5/project": "^3.4.2",
+		"@jridgewell/trace-mapping": "^0.3.19",
+		"@ui5/project": "^3.7.1",
 		"ava": "^5.3.1",
-		"chai": "^4.3.7",
+		"chai": "^4.3.10",
 		"chai-fs": "^2.0.0",
 		"chokidar-cli": "^3.0.0",
 		"cross-env": "^7.0.3",
-		"depcheck": "^1.4.3",
-		"docdash": "^2.0.1",
-		"eslint": "^8.45.0",
+		"depcheck": "^1.4.6",
+		"docdash": "^2.0.2",
+		"eslint": "^8.51.0",
 		"eslint-config-google": "^0.14.0",
 		"eslint-plugin-ava": "^14.0.0",
-		"eslint-plugin-jsdoc": "^46.4.4",
-		"esmock": "^2.3.1",
+		"eslint-plugin-jsdoc": "^46.8.2",
+		"esmock": "^2.5.2",
+		"line-column": "^1.0.2",
 		"nyc": "^15.1.0",
 		"open-cli": "^7.2.0",
 		"recursive-readdir": "^2.2.3",
-		"sinon": "^15.2.0",
+		"sinon": "^16.1.0",
 		"tap-xunit": "^2.4.1"
 	}
 }