@ui5/builder 3.5.1 → 4.0.1

package/lib/processors/bundlers/moduleBundler.js

@@ -33,10 +33,10 @@ const log = getLogger("builder:processors:bundlers:moduleBundler");
  *      the ui5loader is available.
  *	</li>
  *	<li>
- *		<code>require</code>: A 'require' section is transformed into a sequence of jQuery.sap.require calls. The
- *		list will be resolved like an include pattern list in any of the other sections and for each of the resolved
- *		modules, a jQuery.sap.require will be created. In case the ui5loader is available, 'sap.ui.requireSync' is
- *		used instead.
+ *		<code>require</code>: A `require` section is transformed into a `sap.ui.require` call with all the dependencies
+ *		resolved. This module comes with an `async` flag. When set to false, the modules
+ *		are loaded using `sap.ui.requireSync` instead of `sap.ui.require`.
+ *		**Note:** The `sap.ui.requireSync` API is not available in UI5 version 2.x.
  *	</li>
  *	<li>
  *		<code>bundleInfo</code>: A 'bundleInfo' section describes the content of another named bundle. This information
@@ -75,6 +75,11 @@ const log = getLogger("builder:processors:bundlers:moduleBundler");
  * @property {boolean} [declareRawModules=false] Whether raw modules should be declared after jQuery.sap.global
  *		became available. With the usage of the ui5loader, this flag should be set to 'false'
  * @property {boolean} [sort=true] Whether the modules should be sorted by their dependencies
+ * @property {boolean} [async=true] Whether the `require` section of the module should be loaded asynchronously.
+ * 		When set to true, the modules are loaded using a single `sap.ui.require` call instead of multiple
+ *      `sap.ui.requireSync` calls.
+ * 		The latter API is not available in UI5 version 2.x.
+ * 		**Note:** This property is available only for `mode=require`.
  */
 
 /* eslint-disable max-len */
@@ -101,7 +106,6 @@ const log = getLogger("builder:processors:bundlers:moduleBundler");
  *   with an optimization marker
  * @property {boolean} [addTryCatchRestartWrapper=false] Whether to wrap bootable bundles with
  *   a try/catch to filter out "Restart" errors
- * @property {boolean} [usePredefineCalls=false] If set to 'true', sap.ui.predefine is used for UI5 modules
  * @property {number} [numberOfParts=1] The number of parts the module bundle should be splitted
  * @property {boolean} [ignoreMissingModules=false] When searching for modules which are optional for further
  *   processing, do not throw in case they are missing
@@ -133,26 +137,33 @@ const log = getLogger("builder:processors:bundlers:moduleBundler");
 				bundle definition
  * @param {module:@ui5/builder/processors/bundlers/moduleBundler~ModuleBundleOptions} [parameters.options.bundleOptions] Module
 				bundle options
+ * @param {string} [parameters.options.targetUi5CoreVersion] Optional semver compliant sap.ui.core project version, e.g '2.0.0'.
+				This allows the bundler to make assumptions on available runtime APIs.
+				Omit if the ultimate UI5 version at runtime is unknown or can't be determined.
+ * @param {boolean} [parameters.options.allowStringBundling=false] Optional flag to allow bundling of modules as a string.
  * @returns {Promise<module:@ui5/builder/processors/bundlers/moduleBundler~ModuleBundlerResult[]>}
  * Promise resolving with module bundle resources
  */
 /* eslint-enable max-len */
-export default function({resources, options: {bundleDefinition, bundleOptions, moduleNameMapping}}) {
+export default function({resources, options: {
+	bundleDefinition, bundleOptions, moduleNameMapping, targetUi5CoreVersion, allowStringBundling = false
+}}) {
 	// Apply defaults without modifying the passed object
 	bundleOptions = Object.assign({}, {
 		optimize: true,
 		sourceMap: true,
 		decorateBootstrapModule: false,
 		addTryCatchRestartWrapper: false,
-		usePredefineCalls: false,
 		numberOfParts: 1,
 		ignoreMissingModules: false
 	}, bundleOptions);
 
+	// bundleDefinition's defaults get applied in the corresponding standard tasks
+
 	const pool = new LocatorResourcePool({
 		ignoreMissingModules: bundleOptions.ignoreMissingModules
 	});
-	const builder = new BundleBuilder(pool);
+	const builder = new BundleBuilder(pool, targetUi5CoreVersion, allowStringBundling);
 
 	if (log.isLevelEnabled("verbose")) {
 		log.verbose(`Generating bundle:`);

package/lib/processors/jsdoc/apiIndexGenerator.js

@@ -1,5 +1,5 @@
 import {createResource} from "@ui5/fs/resourceFactory";
-import createIndex from "./lib/createIndexFiles.cjs";
+import createIndex from "./lib/createIndexFiles.js";
 
 /**
  * @public

package/lib/processors/jsdoc/jsdocGenerator.js

@@ -4,12 +4,8 @@ import path from "node:path";
 import {promisify} from "node:util";
 const writeFile = promisify(fs.writeFile);
 import {createAdapter} from "@ui5/fs/resourceFactory";
-import {createRequire} from "node:module";
 import {fileURLToPath} from "node:url";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-
 /**
  * @public
  * @module @ui5/builder/processors/jsdoc/jsdocGenerator
@@ -93,12 +89,9 @@ async function generateJsdocConfig({targetPath, tmpPath, namespace, projectName,
 	const backslashRegex = /\\/g;
 
 	// Resolve path to this script to get the path to the JSDoc extensions folder
-	const jsdocPath = path.normalize(__dirname);
-	const pluginPath = path.join(jsdocPath, "lib", "ui5", "plugin.cjs").replace(backslashRegex, "\\\\");
-	// Using export via package.json to allow loading the CJS template.
-	// jsdoc appends /publish to the provided path but doesn't allow to
-	// add the .cjs extension, so loading won't work otherwise.
-	const templatePath = "@ui5/builder/internal/jsdoc/template";
+	const jsdocPath = path.normalize(import.meta.dirname);
+	const pluginPath = path.join(jsdocPath, "lib", "ui5", "plugin.js").replace(backslashRegex, "\\\\");
+	const templatePath = path.join(jsdocPath, "lib", "ui5", "template").replace(backslashRegex, "\\\\");
 	const destinationPath = path.normalize(tmpPath).replace(backslashRegex, "\\\\");
 	const jsapiFilePath = path.join(targetPath, "libraries", projectName + ".js").replace(backslashRegex, "\\\\");
 	const apiJsonFolderPath = path.join(tmpPath, "dependency-apis").replace(backslashRegex, "\\\\");
@@ -164,7 +157,7 @@ async function writeJsdocConfig(targetDirPath, config) {
  */
 async function buildJsdoc({sourcePath, configPath}) {
 	const args = [
-		require.resolve("jsdoc/jsdoc"),
+		fileURLToPath(import.meta.resolve("jsdoc/jsdoc.js")),
 		"-c",
 		configPath,
 		"--verbose",

package/lib/processors/jsdoc/lib/package.json

@@ -0,0 +1,3 @@
+{
+	"type": "commonjs"
+}

package/lib/processors/jsdoc/lib/ui5/template/{publish.cjs → publish.js}

@@ -26,7 +26,7 @@ const info = logger.info.bind(logger);
 const warning = logger.warn.bind(logger);
 const error = logger.error.bind(logger);
 
-const {extractVersion, extractSince} = require("./utils/versionUtil.cjs");
+const {extractVersion, extractSince} = require("./utils/versionUtil");
 
 /* errors that might fail the build in future */
 function future(msg) {

package/lib/processors/jsdoc/sdkTransformer.js

@@ -1,5 +1,5 @@
 import {createResource} from "@ui5/fs/resourceFactory";
-import transformer from "./lib/transformApiJson.cjs";
+import transformer from "./lib/transformApiJson.js";
 
 /**
  * @public

package/lib/processors/manifestEnhancer.js

@@ -0,0 +1,425 @@
+import semver from "semver";
+const {SemVer: Version, lt} = semver;
+import {promisify} from "node:util";
+import path from "node:path/posix";
+import {getLogger} from "@ui5/logger";
+const log = getLogger("builder:processors:manifestEnhancer");
+
+const APP_DESCRIPTOR_V22 = new Version("1.21.0");
+
+function isAbsoluteUrl(url) {
+	if (url.startsWith("/")) {
+		return true;
+	}
+	try {
+		const parsedUrl = new URL(url);
+		// URL with ui5 protocol shouldn't be treated as absolute URL and will be handled separately
+		return parsedUrl.protocol !== "ui5:";
+	} catch (err) {
+		// URL constructor without base requires absolute URL and throws an error for relative URLs
+		return false;
+	}
+}
+
+/**
+ * Returns a bundle URL from the given bundle name, relative to the given namespace.
+ *
+ * @param {string} bundleName Bundle name (e.g. "sap.ui.demo.app.i18n.i18n") to be resolved to a relative URL
+ * @param {string} sapAppId Project namespace from sap.app/id (e.g. "sap.ui.demo.app")
+ *                          to which a bundleName should be resolved to
+ * @returns {string} Relative bundle URL (e.g. "i18n/i18n.properties")
+ */
+function getRelativeBundleUrlFromName(bundleName, sapAppId) {
+	const bundleUrl = "/resources/" + bundleName.replace(/\./g, "/") + ".properties";
+	return normalizeBundleUrl(bundleUrl, sapAppId);
+}
+
+// Copied from sap/base/util/LoaderExtensions.resolveUI5Url
+// Adjusted to not resolve the URL, but create an absolute path prefixed with /resources
+function resolveUI5Url(sUrl) {
+	// check for ui5 scheme
+	if (sUrl.startsWith("ui5:")) {
+		let sNoScheme = sUrl.replace("ui5:", "");
+
+		// check for authority
+		if (!sNoScheme.startsWith("//")) {
+			// URLs using the 'ui5' protocol must be absolute.
+			// Relative and server absolute URLs are reserved for future use.
+			return null;
+		}
+
+		sNoScheme = sNoScheme.replace("//", "");
+
+		return "/resources/" + sNoScheme;
+	} else {
+		// not a ui5 url
+		return sUrl;
+	}
+}
+
+/**
+ * Normalizes a bundle URL relative to the project namespace.
+ *
+ * @param {string} bundleUrl Relative bundle URL to be normalized
+ * @param {string} sapAppId Project namespace from sap.app/id (e.g. "sap.ui.demo.app")
+ *                          to which the URL is relative to
+ * @returns {string} Normalized relative bundle URL (e.g. "i18n/i18n.properties")
+ */
+function normalizeBundleUrl(bundleUrl, sapAppId) {
+	// Create absolute path with namespace from sap.app/id
+	const absoluteNamespace = `/resources/${sapAppId.replaceAll(/\./g, "/")}`;
+
+	const resolvedAbsolutePath = path.resolve(absoluteNamespace, bundleUrl);
+	const resolvedRelativePath = path.relative(absoluteNamespace, resolvedAbsolutePath);
+	return resolvedRelativePath;
+}
+
+/**
+ * Returns the bundle URL from the given bundle configuration.
+ *
+ * @param {object} bundleConfig Bundle configuration
+ * @param {string} sapAppId Project namespace from sap.app/id (e.g. "sap.ui.demo.app")
+ *                          to which a bundleName should be resolved to
+ * @param {string} [defaultBundleUrl] Default bundle url in case bundleConfig is not defined
+ */
+function getBundleUrlFromConfig(bundleConfig, sapAppId, defaultBundleUrl) {
+	if (!bundleConfig) {
+		// Use default URL (or undefined if argument is not provided)
+		return defaultBundleUrl;
+	} else if (typeof bundleConfig === "string") {
+		return bundleConfig;
+	} else if (typeof bundleConfig === "object") {
+		return getBundleUrlFromConfigObject(bundleConfig, sapAppId);
+	}
+}
+
+// Same as above, but does only accept objects, not strings or defaults
+function getBundleUrlFromConfigObject(bundleConfig, sapAppId, fallbackBundleUrl) {
+	if (typeof bundleConfig === "object") {
+		if (bundleConfig.bundleName) {
+			return getRelativeBundleUrlFromName(bundleConfig.bundleName, sapAppId);
+		} else if (bundleConfig.bundleUrl) {
+			return bundleConfig.bundleUrl;
+		}
+	}
+	return fallbackBundleUrl;
+}
+
+// See runtime logic in sap/ui/core/Lib#_normalizeI18nSettings
+function getBundleUrlFromSapUi5LibraryI18n(vI18n) {
+	if (vI18n == null || vI18n === true) {
+		return "messagebundle.properties";
+	} else if (typeof vI18n === "string") {
+		return vI18n;
+	} else if (typeof vI18n === "object") {
+		return vI18n.bundleUrl;
+	} else {
+		return null;
+	}
+}
+
+class ManifestEnhancer {
+	/**
+	 * @param {string} manifest manifest.json content
+	 * @param {string} filePath manifest.json file path
+	 * @param {fs} fs Node fs or custom [fs interface]{@link module:@ui5/fs/fsInterface}
+	 */
+	constructor(manifest, filePath, fs) {
+		this.fsReadDir = promisify(fs.readdir);
+		this.cwd = path.dirname(filePath);
+		this.filePath = filePath;
+		this.manifest = JSON.parse(manifest);
+
+		this.isModified = false;
+		this.runInvoked = false;
+	}
+
+	markModified() {
+		this.isModified = true;
+	}
+
+	async readdir(relativePath) {
+		const absolutePath = path.resolve(this.cwd, relativePath);
+		try {
+			return await this.fsReadDir(absolutePath);
+		} catch (err) {
+			if (err?.code === "ENOENT") {
+				return [];
+			} else {
+				throw err;
+			}
+		}
+	}
+
+	async findSupportedLocales(i18nBundleUrl) {
+		const i18nBundleName = path.basename(i18nBundleUrl, ".properties");
+		const i18nBundlePrefix = `${i18nBundleName}_`;
+		const i18nBundleDir = path.dirname(i18nBundleUrl);
+		const i18nBundleFiles = await this.readdir(i18nBundleDir);
+		const supportedLocales = [];
+		i18nBundleFiles.forEach((fileName) => {
+			if (!fileName.endsWith(".properties")) {
+				return;
+			}
+			const fileNameWithoutExtension = path.basename(fileName, ".properties");
+			if (fileNameWithoutExtension === i18nBundleName) {
+				supportedLocales.push("");
+			} else if (fileNameWithoutExtension.startsWith(i18nBundlePrefix)) {
+				const locale = fileNameWithoutExtension.replace(i18nBundlePrefix, "");
+				supportedLocales.push(locale);
+			}
+		});
+		return supportedLocales.sort();
+	}
+
+	async processBundleConfig({bundleConfig, fallbackBundleUrl, isTerminologyBundle = false, fallbackLocale}) {
+		const bundleUrl = getBundleUrlFromConfigObject(bundleConfig, this.manifest["sap.app"].id, fallbackBundleUrl);
+		if (!bundleUrl) {
+			return;
+		}
+		if (bundleConfig.supportedLocales) {
+			return;
+		}
+
+		const supportedLocales = await this.getSupportedLocales(
+			bundleUrl, fallbackLocale ?? bundleConfig.fallbackLocale, isTerminologyBundle
+		);
+		if (supportedLocales.length > 0) {
+			bundleConfig.supportedLocales = supportedLocales;
+			this.markModified();
+		}
+	}
+
+	async getSupportedLocales(bundleUrl, fallbackLocale, isTerminologyBundle = false) {
+		// Ignore absolute URLs
+		if (isAbsoluteUrl(bundleUrl)) {
+			return [];
+		}
+		const resolvedBundleUrl = resolveUI5Url(bundleUrl);
+		if (!resolvedBundleUrl) {
+			// In case of a relative ui5-protocol URL
+			return [];
+		}
+		const sapAppId = this.manifest["sap.app"].id;
+		const normalizedBundleUrl = normalizeBundleUrl(resolvedBundleUrl, sapAppId);
+		if (normalizedBundleUrl.startsWith("../")) {
+			log.verbose(
+				`${this.filePath}: ` +
+				`bundleUrl '${bundleUrl}' points to a bundle outside of the ` +
+				`current namespace '${sapAppId}', enhancement of 'supportedLocales' is skipped`
+			);
+			return [];
+		}
+		const supportedLocales = await this.findSupportedLocales(normalizedBundleUrl);
+		if (!isTerminologyBundle && supportedLocales.length > 0) {
+			if (typeof fallbackLocale === "string" && !supportedLocales.includes(fallbackLocale)) {
+				log.error(
+					`${this.filePath}: ` +
+					`Generated supported locales ('${supportedLocales.join("', '")}') for ` +
+					`bundle '${normalizedBundleUrl}' ` +
+					"not containing the defined fallback locale '" + fallbackLocale + "'. Either provide a " +
+					"properties file for defined fallbackLocale or configure another available fallbackLocale"
+				);
+				return [];
+			} else if (typeof fallbackLocale === "undefined" && !supportedLocales.includes("en")) {
+				log.warn(
+					`${this.filePath}: ` +
+					`Generated supported locales ('${supportedLocales.join("', '")}') for ` +
+					`bundle '${normalizedBundleUrl}' ` +
+					"do not contain default fallback locale 'en'. Either provide a " +
+					"properties file for 'en' or configure another available fallbackLocale"
+				);
+			}
+		}
+		return supportedLocales;
+	}
+
+	async processSapAppI18n() {
+		const sapApp = this.manifest["sap.app"];
+		let sapAppI18n = sapApp.i18n;
+
+		// Process enhanceWith bundles first, as they check for an existing supportedLocales property
+		// defined by the developer, but not the one generated by the tooling.
+		await this.processTerminologiesAndEnhanceWith(sapAppI18n);
+
+		const i18nBundleUrl = getBundleUrlFromConfig(sapAppI18n, sapApp.id, "i18n/i18n.properties");
+
+		if (!sapAppI18n?.supportedLocales && i18nBundleUrl) {
+			const supportedLocales = await this.getSupportedLocales(i18nBundleUrl, sapAppI18n?.fallbackLocale);
+			if (supportedLocales.length > 0) {
+				if (!sapAppI18n || typeof sapAppI18n === "string") {
+					sapAppI18n = sapApp.i18n = {
+						bundleUrl: i18nBundleUrl
+					};
+				}
+				sapAppI18n.supportedLocales = supportedLocales;
+				this.markModified();
+			}
+		}
+	}
+
+	/**
+	 *	Processes the terminologies and enhanceWith bundles of a bundle configuration.
+	 *
+	 * @param {object} bundleConfig
+	 */
+	async processTerminologiesAndEnhanceWith(bundleConfig) {
+		const bundleConfigs = [];
+		const terminologyBundleConfigs = [];
+
+		if (bundleConfig?.terminologies) {
+			terminologyBundleConfigs.push(...Object.values(bundleConfig.terminologies));
+		}
+
+		bundleConfig?.enhanceWith?.forEach((config) => {
+			// The runtime logic propagates supportedLocales information to the enhanceWith bundles.
+			// In order to not break existing behavior, we do not generate supportedLocales for enhanceWith bundles
+			// in case the parent bundle does have supportedLocales defined.
+			if (!bundleConfig.supportedLocales) {
+				bundleConfigs.push({config, fallbackLocale: bundleConfig.fallbackLocale});
+			}
+			if (config.terminologies) {
+				terminologyBundleConfigs.push(...Object.values(config.terminologies));
+			}
+		});
+
+		await Promise.all(
+			bundleConfigs.map(({config, fallbackLocale}) => this.processBundleConfig({
+				bundleConfig: config,
+				fallbackLocale
+			}))
+		);
+		await Promise.all(
+			terminologyBundleConfigs.map((bundleConfig) => this.processBundleConfig({
+				bundleConfig, isTerminologyBundle: true
+			}))
+		);
+	}
+
+	async processSapUi5Models() {
+		const sapUi5Models = this.manifest["sap.ui5"]?.models;
+		if (typeof sapUi5Models !== "object") {
+			return;
+		}
+		const modelConfigs = Object.values(sapUi5Models)
+			.filter((modelConfig) => modelConfig.type === "sap.ui.model.resource.ResourceModel");
+
+		await Promise.all(
+			modelConfigs.map(async (modelConfig) => {
+				// Process enhanceWith bundles first, as they check for an existing supportedLocales property
+				// defined by the developer, but not the one generated by the tooling.
+				await this.processTerminologiesAndEnhanceWith(modelConfig.settings);
+
+				// Fallback to empty settings object in case only a "uri" is defined which will be converted
+				// to a settings object at runtime.
+				const settings = modelConfig.settings || {};
+
+				// Ensure to pass the "uri" property as fallback bundle URL according to the runtime logic.
+				// It is only taken into account if no "bundleUrl" or "bundleName" is defined.
+				await this.processBundleConfig({bundleConfig: settings, fallbackBundleUrl: modelConfig.uri});
+
+				// Ensure that the settings object is assigned back to the modelConfig
+				// in case it didn't existing before.
+				if (!modelConfig.settings) {
+					modelConfig.settings = settings;
+				}
+			})
+		);
+	}
+
+	async processSapUi5LibraryI18n() {
+		let sapUi5LibraryI18n = this.manifest["sap.ui5"]?.library?.i18n;
+
+		// Process enhanceWith bundles first, as they check for an existing supportedLocales property
+		// defined by the developer, but not the one generated by the tooling.
+		await this.processTerminologiesAndEnhanceWith(sapUi5LibraryI18n);
+
+		const i18nBundleUrl = getBundleUrlFromSapUi5LibraryI18n(sapUi5LibraryI18n);
+		if (i18nBundleUrl && !sapUi5LibraryI18n?.supportedLocales) {
+			const supportedLocales = await this.getSupportedLocales(i18nBundleUrl, sapUi5LibraryI18n?.fallbackLocale);
+			if (supportedLocales.length > 0) {
+				if (!sapUi5LibraryI18n || typeof sapUi5LibraryI18n !== "object") {
+					this.manifest["sap.ui5"] ??= {};
+					this.manifest["sap.ui5"].library ??= {};
+					sapUi5LibraryI18n = this.manifest["sap.ui5"].library.i18n = {
+						bundleUrl: i18nBundleUrl
+					};
+				}
+				sapUi5LibraryI18n.supportedLocales = supportedLocales;
+				this.markModified();
+			}
+		}
+	}
+
+	async run() {
+		// Prevent multiple invocations
+		if (this.runInvoked) {
+			throw new Error("ManifestEnhancer#run can only be invoked once per instance");
+		}
+		this.runInvoked = true;
+
+		if (!this.manifest._version) {
+			log.verbose(`${this.filePath}: _version is not defined. No supportedLocales can be generated`);
+			return;
+		}
+
+		if (lt(this.manifest._version, APP_DESCRIPTOR_V22)) {
+			log.verbose(`${this.filePath}: _version is lower than 1.21.0 so no supportedLocales can be generated`);
+			return;
+		}
+
+		if (!this.manifest["sap.app"]?.id) {
+			log.verbose(`${this.filePath}: sap.app/id is not defined. No supportedLocales can be generated`);
+			return;
+		}
+
+		if (this.manifest["sap.app"].type === "library") {
+			await this.processSapUi5LibraryI18n();
+		} else {
+			await Promise.all([
+				this.processSapAppI18n(),
+				this.processSapUi5Models()
+			]);
+		}
+
+		if (this.isModified) {
+			return this.manifest;
+		}
+	}
+}
+
+/**
+ * @module @ui5/builder/processors/manifestEnhancer
+ */
+
+/**
+ * Enriches the content of the manifest.json file.
+ *
+ * @public
+ * @function default
+ * @static
+ *
+ * @param {object} parameters Parameters
+ * @param {@ui5/fs/Resource[]} parameters.resources List of manifest.json resources to be processed
+ * @param {fs|module:@ui5/fs/fsInterface} parameters.fs Node fs or custom
+ *    [fs interface]{@link module:@ui5/fs/fsInterface}.
+ * @returns {Promise<Array<@ui5/fs/Resource|undefined>>} Promise resolving with an array of modified resources
+ */
+export default async function({resources, fs}) {
+	const res = await Promise.all(
+		resources.map(async (resource) => {
+			const manifest = await resource.getString();
+			const filePath = resource.getPath();
+			const manifestEnhancer = new ManifestEnhancer(manifest, filePath, fs);
+			const enrichedManifest = await manifestEnhancer.run();
+			if (enrichedManifest) {
+				resource.setString(JSON.stringify(enrichedManifest, null, 2));
+				return resource;
+			}
+		})
+	);
+	return res.filter(($) => $);
+}
+
+export const __internals__ = (process.env.NODE_ENV === "test") ?
+	{ManifestEnhancer, getRelativeBundleUrlFromName, normalizeBundleUrl, resolveUI5Url} : undefined;

package/lib/processors/minifier.js

@@ -42,6 +42,10 @@ function getPool(taskUtil) {
 				let {idleWorkers, totalWorkers} = pool.stats();
 				while (idleWorkers !== totalWorkers && !force) {
 					await setTimeoutPromise(100); // Wait a bit workers to finish and try again
+
+					if (!pool) { // pool might have been terminated in the meantime
+						return;
+					}
 					({idleWorkers, totalWorkers} = pool.stats());
 				}
 
@@ -222,7 +226,7 @@ export default async function({
 					const sourceMapJson = JSON.parse(sourceMapContent);
 
 					if (sourceMapJson.sections) {
-						// TODO 4.0
+						// TODO 5.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

package/lib/tasks/buildThemes.js

@@ -37,6 +37,10 @@ function getPool(taskUtil) {
 				let {idleWorkers, totalWorkers} = pool.stats();
 				while (idleWorkers !== totalWorkers && !force) {
 					await setTimeoutPromise(100); // Wait a bit workers to finish and try again
+
+					if (!pool) { // pool might have been terminated in the meantime
+						return;
+					}
 					({idleWorkers, totalWorkers} = pool.stats());
 				}
 

package/lib/tasks/bundlers/generateBundle.js

@@ -1,4 +1,5 @@
 import moduleBundler from "../../processors/bundlers/moduleBundler.js";
+import {applyDefaultsToBundleDefinition} from "./utils/applyDefaultsToBundleDefinition.js";
 import createModuleNameMapping from "./utils/createModuleNameMapping.js";
 import ReaderCollectionPrioritized from "@ui5/fs/ReaderCollectionPrioritized";
 
@@ -94,12 +95,20 @@ export default async function({
 			}
 		});
 	}
-
+	const coreVersion = taskUtil?.getProject("sap.ui.core")?.getVersion();
+	const allowStringBundling = taskUtil?.getProject().getSpecVersion().lt("4.0");
 	return combo.byGlob("/resources/**/*.{js,json,xml,html,properties,library,js.map}").then((resources) => {
-		const options = {bundleDefinition, bundleOptions};
+		const options = {
+			bundleDefinition: applyDefaultsToBundleDefinition(bundleDefinition, taskUtil),
+			bundleOptions,
+			allowStringBundling
+		};
 		if (!optimize && taskUtil) {
 			options.moduleNameMapping = createModuleNameMapping({resources, taskUtil});
 		}
+		if (coreVersion) {
+			options.targetUi5CoreVersion = coreVersion;
+		}
 		return moduleBundler({options, resources}).then((bundles) => {
 			return Promise.all(bundles.map(({bundle, sourceMap} = {}) => {
 				if (!bundle) {

package/lib/tasks/bundlers/generateComponentPreload.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import moduleBundler from "../../processors/bundlers/moduleBundler.js";
+import {applyDefaultsToBundleDefinition} from "./utils/applyDefaultsToBundleDefinition.js";
 import {getLogger} from "@ui5/logger";
 const log = getLogger("builder:tasks:bundlers:generateComponentPreload");
 import {negateFilters} from "../../lbt/resources/ResourceFilterList.js";
@@ -144,18 +145,24 @@ export default async function({
 					);
 				});
 			}
-
+			const coreVersion = taskUtil?.getProject("sap.ui.core")?.getVersion();
+			const allowStringBundling = taskUtil?.getProject().getSpecVersion().lt("4.0");
 			return Promise.all(bundleDefinitions.filter(Boolean).map((bundleDefinition) => {
 				log.verbose(`Generating ${bundleDefinition.name}...`);
+				const options = {
+					bundleDefinition: applyDefaultsToBundleDefinition(bundleDefinition, taskUtil),
+					bundleOptions: {
+						ignoreMissingModules: true,
+						optimize: true
+					},
+					allowStringBundling
+				};
+				if (coreVersion) {
+					options.targetUi5CoreVersion = coreVersion;
+				}
 				return moduleBundler({
 					resources,
-					options: {
-						bundleDefinition,
-						bundleOptions: {
-							ignoreMissingModules: true,
-							optimize: true
-						}
-					}
+					options
 				});
 			}));
 		})

package/lib/tasks/bundlers/generateFlexChangesBundle.js

@@ -29,8 +29,7 @@ import semver from "semver";
  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  */
 export default async function({workspace, taskUtil, options = {}}) {
-	// Backward compatibility: "namespace" option got renamed to "projectNamespace"
-	const namespace = options.projectNamespace || options.namespace;
+	const namespace = options.projectNamespace;
 
 	// Use the given namespace if available, otherwise use no namespace
 	// (e.g. in case no manifest.json is present)