@ui5/builder 3.0.0-alpha.1 → 3.0.0-alpha.11

package/lib/lbt/bundle/BundleWriter.js

@@ -11,6 +11,8 @@ const SPACES_OR_TABS_ONLY = /^[ \t]+$/;
  *
  * Most methods have been extracted from JSMergeWriter.
  *
+ * columnOffset and lineOffset are used for sourcemap merging as reference to where we are at a given point in time
+ *
  * @author Frank Weigel
  * @since 1.27.0
  * @private
@@ -18,6 +20,8 @@ const SPACES_OR_TABS_ONLY = /^[ \t]+$/;
 class BundleWriter {
 	constructor() {
 		this.buf = "";
+		this.lineOffset = 0;
+		this.columnOffset = 0;
 		this.segments = [];
 		this.currentSegment = null;
 		this.currentSourceIndex = 0;
@@ -28,6 +32,11 @@ class BundleWriter {
 		let writeBuf = "";
 		for ( let i = 0; i < str.length; i++ ) {
 			writeBuf += str[i];
+			if (str[i] != null && str[i].split) {
+				const strSplit = str[i].split(NL);
+				this.lineOffset += strSplit.length - 1;
+				this.columnOffset += strSplit[strSplit.length - 1].length;
+			}
 		}
 		if ( writeBuf.length >= 1 ) {
 			this.buf += writeBuf;
@@ -40,15 +49,23 @@ class BundleWriter {
 	writeln(...str) {
 		for ( let i = 0; i < str.length; i++ ) {
 			this.buf += str[i];
+			if (str[i] != null && str[i].split) {
+				const strSplit = str[i].split(NL);
+				this.lineOffset += strSplit.length - 1;
+			}
 		}
 		this.buf += NL;
 		this.endsWithNewLine = true;
+		this.lineOffset += 1;
+		this.columnOffset = 0;
 	}
 
 	ensureNewLine() {
 		if ( !this.endsWithNewLine ) {
 			this.buf += NL;
 			this.endsWithNewLine = true;
+			this.lineOffset += 1;
+			this.columnOffset = 0;
 		}
 	}
 

package/lib/lbt/bundle/Resolver.js

@@ -292,12 +292,12 @@ class BundleResolver {
 						if ( section.mode == SectionType.Raw && section.sort !== false ) {
 							// sort the modules in topological order
 							return topologicalSort(pool, modules).then( (modules) => {
-								log.verbose("      resolved modules (sorted): %s", modules);
+								log.silly("      resolved modules (sorted): %s", modules);
 								return modules;
 							});
 						}
 
-						log.verbose("      resolved modules: %s", modules);
+						log.silly("      resolved modules: %s", modules);
 						return modules;
 					}).then( function(modules) {
 						resolvedSection.modules = modules;

package/lib/lbt/calls/SapUiDefine.js

@@ -2,7 +2,7 @@
 
 const {Syntax} = require("../utils/parseUtils");
 const ModuleName = require("../utils/ModuleName");
-const {isString, isBoolean} = require("../utils/ASTUtils");
+const {isBoolean, getStringValue} = require("../utils/ASTUtils");
 
 class SapUiDefineCall {
 	constructor(node, moduleName) {
@@ -11,6 +11,7 @@ class SapUiDefineCall {
 		this.dependencyArray = null;
 		this.factory = null;
 		this.exportAsGlobal = false;
+		this.paramNames = null;
 
 		const args = node.arguments;
 		if ( args == null ) {
@@ -27,28 +28,33 @@ class SapUiDefineCall {
 		let i = 0;
 		let params;
 
-		if ( i < args.length && isString(args[i]) ) {
+		const name = getStringValue(args[i]);
+		if ( i < args.length && name ) {
 			// assert(String)
-			this.name = args[i++].value;
+			this.name = name;
+			i++;
 		}
 
 		if ( i < args.length && args[i].type === Syntax.ArrayExpression ) {
 			this.dependencyArray = args[i++];
 			this.dependencies = this.dependencyArray.elements.map( (elem) => {
-				if ( !isString(elem) ) {
+				const value = getStringValue(elem);
+				if ( !value ) {
 					throw new TypeError();
 				}
-				return ModuleName.resolveRelativeRequireJSName(this.name, elem.value);
+				return ModuleName.resolveRelativeRequireJSName(this.name, value);
 			});
 			this.dependencyInsertionIdx = this.dependencyArray.elements.length;
 		}
 
-		if ( i < args.length && args[i].type === Syntax.FunctionExpression ) {
+		if ( i < args.length && (
+			args[i].type === Syntax.FunctionExpression || args[i].type === Syntax.ArrowFunctionExpression)
+		) {
 			this.factory = args[i++];
 			params = this.factory.params;
 			this.paramNames = params.map( (param) => {
 				if ( param.type !== Syntax.Identifier ) {
-					throw new TypeError();
+					return null;
 				}
 				return param.name;
 			});

package/lib/lbt/resources/LocatorResource.js

@@ -1,12 +1,8 @@
 const Resource = require("./Resource");
 
-function extractName(path) {
-	return path.slice( "/resources/".length);
-}
-
 class LocatorResource extends Resource {
-	constructor(pool, resource) {
-		super(pool, extractName(resource.getPath()), null, resource.getStatInfo());
+	constructor(pool, resource, moduleName) {
+		super(pool, moduleName, null, resource.getStatInfo());
 		this.resource = resource;
 	}
 
@@ -15,7 +11,11 @@ class LocatorResource extends Resource {
 	}
 
 	getProject() {
-		return this.resource._project;
+		return this.resource.getProject();
+	}
+
+	getPath() {
+		return this.resource.getPath();
 	}
 }
 

package/lib/lbt/resources/LocatorResourcePool.js

@@ -2,12 +2,16 @@ const ResourcePool = require("./ResourcePool");
 const LocatorResource = require("./LocatorResource");
 
 class LocatorResourcePool extends ResourcePool {
-	prepare(resources) {
+	prepare(resources, moduleNameMapping) {
 		resources = resources.filter( (res) => !res.getStatInfo().isDirectory() );
 		return Promise.all(
-			resources.map(
-				(resource) => this.addResource( new LocatorResource(this, resource) )
-			).filter(Boolean)
+			resources.map((resource) => {
+				let moduleName = moduleNameMapping && moduleNameMapping[resource.getPath()];
+				if (!moduleName) {
+					moduleName = resource.getPath().slice("/resources/".length);
+				}
+				return this.addResource(new LocatorResource(this, resource, moduleName));
+			}).filter(Boolean)
 		);
 	}
 }

package/lib/lbt/resources/ResourceCollector.js

@@ -110,10 +110,11 @@ class ResourceCollector {
 	}
 
 	async enrichWithDependencyInfo(resourceInfo) {
-		return this._pool.getModuleInfo(resourceInfo.name).then(async (moduleInfo) => {
-			if ( moduleInfo.name ) {
+		return this._pool.getModuleInfo(resourceInfo.name, resourceInfo.module).then(async (moduleInfo) => {
+			if ( !resourceInfo.module && moduleInfo.name ) {
 				resourceInfo.module = moduleInfo.name;
 			}
+
 			if ( moduleInfo.dynamicDependencies ) {
 				resourceInfo.dynRequired = true;
 			}
@@ -279,37 +280,43 @@ class ResourceCollector {
 
 		await Promise.all(promises);
 
-		const debugBundlePromises = [];
-
-		for (let i = debugResourcesInfo.length - 1; i >= 0; i--) {
-			const dbgInfo = debugResourcesInfo[i];
-			const nonDebugName = ResourceInfoList.getNonDebugName(dbgInfo.name);
+		await Promise.all(debugResourcesInfo.map(async (dbgInfo) => {
+			const debugName = dbgInfo.name;
+			const nonDebugName = ResourceInfoList.getNonDebugName(debugName);
 			const nonDbgInfo = this._resources.get(nonDebugName);
 
 			// FIXME: "merged" property is only calculated in ResourceInfo#copyFrom
 			// Therefore using the same logic here to compute it.
+
+			// TODO: Idea: Use IsDebugVariant tag to decide whether to analyze the resource
+			// If the tag is set, we don't expect different analysis results so we can copy the info (else-path)
+			// Only when the tag is not set, we analyze the resource with its name (incl. -dbg)
+
 			if (!nonDbgInfo || (nonDbgInfo.included != null && nonDbgInfo.included.size > 0)) {
 				// We need to analyze the dbg resource if there is no non-dbg variant or
 				// it is a bundle because we will (usually) have different content.
-				debugBundlePromises.push(
-					this.enrichWithDependencyInfo(dbgInfo)
-				);
+
+				if (nonDbgInfo) {
+					// Always use the non-debug module name, if available
+					dbgInfo.module = nonDbgInfo.module;
+				}
+				await this.enrichWithDependencyInfo(dbgInfo);
 			} else {
 				// If the non-dbg resource is not a bundle, we can just copy over the info and skip
 				// analyzing the dbg variant as both should have the same info.
 
-				const newDbgInfo = new ResourceInfo(dbgInfo.name);
+				const newDbgInfo = new ResourceInfo(debugName);
 
 				// First copy info of analysis from non-dbg file (included, required, condRequired, ...)
 				newDbgInfo.copyFrom(null, nonDbgInfo);
 				// Then copy over info from dbg file to properly set name, isDebug, etc.
 				newDbgInfo.copyFrom(null, dbgInfo);
+				// Finally, set the module name to the non-dbg name
+				newDbgInfo.module = nonDbgInfo.module;
 
-				this._resources.set(dbgInfo.name, newDbgInfo);
+				this._resources.set(debugName, newDbgInfo);
 			}
-		}
-
-		await Promise.all(debugBundlePromises);
+		}));
 	}
 
 	createOrphanFilters() {

package/lib/lbt/resources/ResourceInfoList.js

@@ -48,7 +48,6 @@ class ResourceInfoList {
 		if ( myInfo == null ) {
 			myInfo = new ResourceInfo(relativeName);
 			myInfo.size = info.size;
-			myInfo.module = ResourceInfoList.getNonDebugName(info.name);
 			this.resources.push(myInfo);
 			this.resourcesByName.set(relativeName, myInfo);
 		}

package/lib/lbt/resources/ResourcePool.js

@@ -176,17 +176,18 @@ class ResourcePool {
 	/**
 	 * Retrieves the module info
 	 *
-	 * @param {string} name module name
+	 * @param {string} resourceName resource/module name
+	 * @param {string} [moduleName] module name, in case it differs from the resource name (e.g. for -dbg resources)
 	 * @returns {Promise<ModuleInfo>}
 	 */
-	async getModuleInfo(name) {
-		let info = this._dependencyInfos.get(name);
+	async getModuleInfo(resourceName, moduleName) {
+		let info = this._dependencyInfos.get(resourceName);
 		if ( info == null ) {
 			info = Promise.resolve().then(async () => {
-				const resource = await this.findResource(name);
-				return determineDependencyInfo( resource, this._rawModuleInfos.get(name), this );
+				const resource = await this.findResource(resourceName);
+				return determineDependencyInfo( resource, this._rawModuleInfos.get(moduleName || resourceName), this );
 			});
-			this._dependencyInfos.set(name, info);
+			this._dependencyInfos.set(resourceName, info);
 		}
 		return info;
 	}

package/lib/lbt/utils/ASTUtils.js

@@ -13,10 +13,31 @@ const {Syntax} = require("../utils/parseUtils");
  * @returns {boolean} Whether the node is a literal and whether its value matches the given string
  */
 function isString(node, literal) {
-	if ( node == null || node.type !== Syntax.Literal || typeof node.value !== "string" ) {
+	const value = getStringValue(node);
+	if (value === undefined) {
 		return false;
 	}
-	return literal == null ? true : node.value === literal;
+	return literal == null ? true: value === literal;
+}
+
+function getStringValue(node) {
+	if (isLiteral(node)) {
+		return node.value;
+	} else if (isTemplateLiteralWithoutExpression(node)) {
+		return node?.quasis?.[0]?.value?.cooked;
+	} else {
+		return undefined;
+	}
+}
+
+function isLiteral(node) {
+	return node && node.type === Syntax.Literal && typeof node.value === "string";
+}
+
+function isTemplateLiteralWithoutExpression(node) {
+	return node?.type === Syntax.TemplateLiteral &&
+		node?.expressions?.length === 0 &&
+		node?.quasis?.length === 1;
 }
 
 function isBoolean(node, literal) {
@@ -47,27 +68,27 @@ function isNamedObject(node, objectPath, length) {
 }
 
 function isIdentifier(node, name) {
-	if ( node.type != Syntax.Identifier ) {
-		return false;
-	}
-	if ( typeof name == "string" ) {
+	if ( node.type === Syntax.Identifier && typeof name == "string" ) {
 		return name === node.name;
+	} else if ( node.type === Syntax.Identifier && Array.isArray(name) ) {
+		return name.find((name) => name === node.name || name === "*") !== undefined;
+	} else if ( node.type === Syntax.ObjectPattern ) {
+		return node.properties.filter((childnode) => isIdentifier(childnode.key, name)).length > 0;
+	} else if ( node.type === Syntax.ArrayPattern ) {
+		return node.elements.filter((childnode) => isIdentifier(childnode, name)).length > 0;
+	} else {
+		return false;
 	}
-	for (let i = 0; i < name.length; i++) {
-		if ( name[i] === node.name || name[i] === "*" ) {
-			return true;
-		}
-	}
-	return false;
 }
 
 function getPropertyKey(property) {
-	if ( property.key.type === Syntax.Identifier ) {
+	if ( property.type === Syntax.SpreadElement ) {
+		// TODO: Support interpreting SpreadElements
+		return;
+	} else if ( property.key.type === Syntax.Identifier && property.computed !== true ) {
 		return property.key.name;
 	} else if ( property.key.type === Syntax.Literal ) {
 		return String(property.key.value);
-	} else {
-		throw new Error();
 	}
 }
 
@@ -102,10 +123,15 @@ function getValue(obj, names) {
  */
 function getStringArray(array, skipNonStringLiterals) {
 	return array.elements.reduce( (result, item) => {
-		if ( isString(item) ) {
-			result.push(item.value);
+		const value = getStringValue(item);
+		if ( value !== undefined ) {
+			result.push(value);
 		} else if ( !skipNonStringLiterals ) {
-			throw new TypeError("array element is not a string literal:" + item.type);
+			if (item.type === Syntax.TemplateLiteral) {
+				throw new TypeError("array element is a template literal with expressions");
+			} else {
+				throw new TypeError("array element is not a string literal: " + item.type);
+			}
 		}
 		return result;
 	}, []);
@@ -113,6 +139,7 @@ function getStringArray(array, skipNonStringLiterals) {
 
 module.exports = {
 	isString,
+	getStringValue,
 	isBoolean,
 	isMethodCall,
 	isNamedObject,

package/lib/lbt/utils/escapePropertiesFile.js

@@ -4,7 +4,7 @@ const nonAsciiEscaper = require("../../processors/nonAsciiEscaper");
  * Can be used to escape *.properties files.
  *
  * Input encoding is read from project configuration.
- * In case the resource belongs to no project (e.g. bundler is used standalone) the default is "ISO-8859-1".
+ * In case the resource belongs to no project (e.g. bundler is used standalone) the default is "UTF-8".
  *
  * @private
  * @param {Resource} resource the resource for which the content will be escaped
@@ -12,13 +12,10 @@ const nonAsciiEscaper = require("../../processors/nonAsciiEscaper");
  */
 module.exports = async function(resource) {
 	const project = resource.getProject();
-	let propertiesFileSourceEncoding = project &&
-			project.resources &&
-			project.resources.configuration &&
-			project.resources.configuration.propertiesFileSourceEncoding;
+	let propertiesFileSourceEncoding = project && project.getPropertiesFileSourceEncoding();
 
 	if (!propertiesFileSourceEncoding) {
-		if (project && ["0.1", "1.0", "1.1"].includes(project.specVersion)) {
+		if (project && ["0.1", "1.0", "1.1"].includes(project.getSpecVersion())) {
 			// default encoding to "ISO-8859-1" for old specVersions
 			propertiesFileSourceEncoding = "ISO-8859-1";
 		} else {

package/lib/lbt/utils/parseUtils.js

@@ -9,7 +9,7 @@ function parseJS(code, userOptions = {}) {
 	// allowed options and their defaults
 	const options = {
 		comment: false,
-		ecmaVersion: 2021,
+		ecmaVersion: 2021, // NOTE: Adopt JSModuleAnalyzer.js to allow new Syntax when upgrading to newer ECMA versions
 		range: false,
 		sourceType: "script",
 	};

package/lib/processors/bundlers/moduleBundler.js

@@ -90,9 +90,10 @@ const log = require("@ui5/logger").getLogger("builder:processors:bundlers:module
  * @public
  * @typedef {object} ModuleBundleOptions
  * @property {boolean} [optimize=true] Whether the module bundle gets minified
- * @property {boolean} [decorateBootstrapModule=false] If set to 'false', the module won't be decorated
+ * @property {boolean} [sourceMap=true] Whether to generate a source map file for the bundle
+ * @property {boolean} [decorateBootstrapModule=false] If set to 'false', bootable bundles won't be decorated
  *   with an optimization marker
- * @property {boolean} [addTryCatchRestartWrapper=false] Whether to wrap bootable module bundles with
+ * @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
@@ -101,21 +102,35 @@ const log = require("@ui5/logger").getLogger("builder:processors:bundlers:module
  */
 
 /**
- * Legacy preload bundler.
+ * Result set
+ *
+ * @public
+ * @typedef {object} ModuleBundlerResult
+ * @property {module:@ui5/fs.Resource} bundle Bundle resource
+ * @property {module:@ui5/fs.Resource} sourceMap Source Map
+ * @memberof module:@ui5/builder.processors
+ */
+
+/**
+ * Legacy module bundler.
  *
  * @public
  * @alias module:@ui5/builder.processors.moduleBundler
  * @param {object} parameters Parameters
  * @param {module:@ui5/fs.Resource[]} parameters.resources Resources
  * @param {object} parameters.options Options
+ * @param {object} [parameters.options.moduleNameMapping]
+ 				Optional mapping of resource paths to module name in order to overwrite the default determination
  * @param {ModuleBundleDefinition} parameters.options.bundleDefinition Module bundle definition
  * @param {ModuleBundleOptions} [parameters.options.bundleOptions] Module bundle options
- * @returns {Promise<module:@ui5/fs.Resource[]>} Promise resolving with module bundle resources
+ * @returns {Promise<module:@ui5/builder.processors.ModuleBundlerResult[]>}
+ * Promise resolving with module bundle resources
  */
-module.exports = function({resources, options: {bundleDefinition, bundleOptions}}) {
+module.exports = function({resources, options: {bundleDefinition, bundleOptions, moduleNameMapping}}) {
 	// Apply defaults without modifying the passed object
 	bundleOptions = Object.assign({}, {
 		optimize: true,
+		sourceMap: true,
 		decorateBootstrapModule: false,
 		addTryCatchRestartWrapper: false,
 		usePredefineCalls: false,
@@ -133,8 +148,7 @@ module.exports = function({resources, options: {bundleDefinition, bundleOptions}
 		log.verbose(`bundleDefinition: ${JSON.stringify(bundleDefinition, null, 2)}`);
 		log.verbose(`bundleOptions: ${JSON.stringify(bundleOptions, null, 2)}`);
 	}
-
-	return pool.prepare( resources ).
+	return pool.prepare( resources, moduleNameMapping ).
 		then( () => builder.createBundle(bundleDefinition, bundleOptions) ).
 		then( (results) => {
 			let bundles;
@@ -146,13 +160,20 @@ module.exports = function({resources, options: {bundleDefinition, bundleOptions}
 
 			return Promise.all(bundles.map((bundleObj) => {
 				if ( bundleObj ) {
-					const {name, content} = bundleObj;
+					const {name, content, sourceMap} = bundleObj;
 					// console.log("creating bundle as '%s'", "/resources/" + name);
-					const resource = new EvoResource({
+					const res = {};
+					res.bundle = new EvoResource({
 						path: "/resources/" + name,
 						string: content
 					});
-					return resource;
+					if (sourceMap) {
+						res.sourceMap = new EvoResource({
+							path: "/resources/" + name + ".map",
+							string: sourceMap
+						});
+					}
+					return res;
 				}
 			}));
 		});

package/lib/processors/jsdoc/lib/createIndexFiles.js

@@ -1,7 +1,7 @@
 /*
  * Node script to create cross-library API index files for use in the UI5 SDKs.
  *
- * (c) Copyright 2009-2021 SAP SE or an SAP affiliate company.
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
  * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
  */