@ui5/builder 3.0.0-beta.1 → 3.0.0-beta.3

package/CHANGELOG.md

@@ -2,7 +2,29 @@
 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.0-beta.1...HEAD).
+A list of unreleased changes can be found [here](https://github.com/SAP/ui5-builder/compare/v3.0.0-beta.3...HEAD).
+
+<a name="v3.0.0-beta.3"></a>
+## [v3.0.0-beta.3] - 2022-11-29
+### Features
+- **jsdoc:** Support destructuring of enums for defaultValue ([#775](https://github.com/SAP/ui5-builder/issues/775)) [`523f365`](https://github.com/SAP/ui5-builder/commit/523f365cb917997c5031d245309c21e9e4b3e311)
+
+
+<a name="v3.0.0-beta.2"></a>
+## [v3.0.0-beta.2] - 2022-11-29
+### Breaking Changes
+- Removal of manifestBundler and generateManifestBundle ([#838](https://github.com/SAP/ui5-builder/issues/838)) [`07a5be2`](https://github.com/SAP/ui5-builder/commit/07a5be2b6d9aa23cf78ddd17951c832d6dec7bef)
+- **JSDoc:** Fail build when jsdoc command failed ([#845](https://github.com/SAP/ui5-builder/issues/845)) [`c2916b4`](https://github.com/SAP/ui5-builder/commit/c2916b4f1d49b5500e4b51143d4e6065ac200eef)
+
+### Features
+- Support ES2022 language features ([#848](https://github.com/SAP/ui5-builder/issues/848)) [`f9b8457`](https://github.com/SAP/ui5-builder/commit/f9b845726731a0e02ec4a499e2a1a82a639174a8)
+
+### BREAKING CHANGE
+
+The `jsdocGenerator` processor and the corresponding `generateJsdoc` task will now throw an error when JSDoc reports an error (exit code != 0). This will also fail the build when running `ui5 build jsdoc`.
+
+The manifestBundler processor and generateManifestBundle task has been removed because it is no longer required for the HTML5 repository in Cloud Foundry.
+
 
 <a name="v3.0.0-beta.1"></a>
 ## [v3.0.0-beta.1] - 2022-11-07
@@ -787,6 +809,8 @@ to load the custom bundle file instead.
 - Add ability to configure component preloads and custom bundles [`2241e5f`](https://github.com/SAP/ui5-builder/commit/2241e5ff98fd95f1f80cc74959655ae7a9c660e7)
 
 
+[v3.0.0-beta.3]: https://github.com/SAP/ui5-builder/compare/v3.0.0-beta.2...v3.0.0-beta.3
+[v3.0.0-beta.2]: https://github.com/SAP/ui5-builder/compare/v3.0.0-beta.1...v3.0.0-beta.2
 [v3.0.0-beta.1]: https://github.com/SAP/ui5-builder/compare/v3.0.0-alpha.12...v3.0.0-beta.1
 [v3.0.0-alpha.12]: https://github.com/SAP/ui5-builder/compare/v3.0.0-alpha.11...v3.0.0-alpha.12
 [v3.0.0-alpha.11]: https://github.com/SAP/ui5-builder/compare/v3.0.0-alpha.10...v3.0.0-alpha.11

package/lib/lbt/analyzer/JSModuleAnalyzer.js

@@ -135,10 +135,10 @@ const EnrichedVisitorKeys = (function() {
 		 * All properties in an object pattern are executed.
 		 */
 		ObjectPattern: [], // properties
-		// PrivateIdentifier: [], // will come with ES2022
+		PrivateIdentifier: [],
 		Program: [],
 		Property: [],
-		// PropertyDefinition: [], // will come with ES2022
+		PropertyDefinition: [],
 		/*
 		 * argument of the rest element is always executed under the same condition as the rest element itself
 		 */
@@ -146,7 +146,7 @@ const EnrichedVisitorKeys = (function() {
 		ReturnStatement: [],
 		SequenceExpression: [],
 		SpreadElement: [], // the argument of the spread operator always needs to be evaluated - argument
-		// StaticBlock: [], // will come with ES2022
+		StaticBlock: [],
 		Super: [],
 		SwitchStatement: [],
 		SwitchCase: ["test", "consequent"], // test and consequent are executed only conditionally
@@ -196,15 +196,6 @@ const EnrichedVisitorKeys = (function() {
 			return;
 		}
 
-		// Ignore new ES2022 syntax as we currently use ES2021 (see parseUtils.js)
-		if (
-			type === "PrivateIdentifier" ||
-			type === "PropertyDefinition" ||
-			type === "StaticBlock"
-		) {
-			return;
-		}
-
 		const visitorKeys = VisitorKeys[type];
 		const condKeys = TempKeys[type];
 		if ( condKeys === undefined ) {
@@ -535,6 +526,15 @@ class JSModuleAnalyzer {
 				}
 				break;
 
+			case Syntax.PropertyDefinition:
+
+				// Instance properties (static=false) are only initialized when an instance is created (conditional)
+				// but a computed key is always evaluated on class initialization (eager)
+				visit(node.key, conditional);
+				visit(node.value, !node.static || conditional);
+
+				break;
+
 			default:
 				if ( condKeys == null ) {
 					log.error("Unhandled AST node type " + node.type, node);

package/lib/lbt/resources/LibraryFileAnalyzer.js

@@ -49,7 +49,7 @@ function createRawInfo(rawModule) {
 }
 
 export function getDependencyInfos( name, content ) {
-	const infos = {};
+	const infos = Object.create(null);
 	parser.parseString(content, (err, result) => {
 		if ( result &&
 				result.library &&

package/lib/lbt/resources/ModuleInfo.js

@@ -39,7 +39,7 @@ class ModuleInfo {
 	constructor(name) {
 		this._name = name;
 		this.subModules = [];
-		this._dependencies = {};
+		this._dependencies = Object.create(null);
 		this.dynamicDependencies = false;
 
 		/**

package/lib/lbt/resources/ResourceCollector.js

@@ -66,7 +66,7 @@ class ResourceCollector {
 	 *
 	 * If no component is given, orphans will only be reported but not added to any component (default).
 	 *
-	 * @param {object<string, string[]>} list component to list of components
+	 * @param {Object<string, string[]>} list component to list of components
 	 */
 	setExternalResources(list) {
 		this._externalResources = list;

package/lib/lbt/utils/ASTUtils.js

@@ -56,6 +56,8 @@ export function isMethodCall(node, methodPath) {
 }
 
 export function isNamedObject(node, objectPath, length) {
+	// TODO: Support PrivateIdentifier (foo.#bar)
+
 	// console.log("checking for named object ", node, objectPath, length);
 	while ( length > 1 &&
 			node.type === Syntax.MemberExpression &&

package/lib/lbt/utils/escapePropertiesFile.js

@@ -15,7 +15,7 @@ export default async function(resource) {
 	let propertiesFileSourceEncoding = project && project.getPropertiesFileSourceEncoding();
 
 	if (!propertiesFileSourceEncoding) {
-		if (project && ["0.1", "1.0", "1.1"].includes(project.getSpecVersion())) {
+		if (project && project.getSpecVersion().lte("1.1")) {
 			// default encoding to "ISO-8859-1" for old specVersions
 			propertiesFileSourceEncoding = "ISO-8859-1";
 		} else {

package/lib/lbt/utils/parseUtils.js

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

package/lib/processors/jsdoc/jsdocGenerator.js

@@ -170,18 +170,16 @@ async function buildJsdoc({sourcePath, configPath}) {
 		"--verbose",
 		sourcePath
 	];
-	return new Promise((resolve, reject) => {
+	const exitCode = await new Promise((resolve /* , reject */) => {
 		const child = spawn("node", args, {
 			stdio: ["ignore", "ignore", "inherit"]
 		});
-		child.on("close", function(code) {
-			if (code === 0 || code === 1) {
-				resolve();
-			} else {
-				reject(new Error(`JSDoc child process closed with code ${code}`));
-			}
-		});
+		child.on("close", resolve);
 	});
+
+	if (exitCode !== 0) {
+		throw new Error(`JSDoc reported an error, check the log for issues (exit code: ${exitCode})`);
+	}
 }
 
 jsdocGenerator._generateJsdocConfig = generateJsdocConfig;

package/lib/processors/jsdoc/lib/transformApiJson.cjs

@@ -989,11 +989,12 @@ function transformer(sInputFile, sOutputFile, sLibraryFile, vDependencyAPIFiles,
 			const {sources} = options;
 			let {librarySrcDir, libraryTestDir} = options;
 
-			// Using path.join to normalize POSIX paths to Windows paths on Windows
-			librarySrcDir = path.join(librarySrcDir);
-			libraryTestDir = path.join(libraryTestDir);
-
 			if (Array.isArray(sources) && typeof librarySrcDir === "string" && typeof libraryTestDir === "string") {
+
+				// Using path.join to normalize POSIX paths to Windows paths on Windows
+				librarySrcDir = path.join(librarySrcDir);
+				libraryTestDir = path.join(libraryTestDir);
+
 				/**
 				 * Calculate prefix to check
 				 *

package/lib/processors/jsdoc/lib/ui5/plugin.cjs

@@ -66,6 +66,7 @@ const fs = require('jsdoc/fs');
 const path = require('jsdoc/path');
 const logger = require('jsdoc/util/logger');
 const pluginConfig = (env.conf && env.conf.templates && env.conf.templates.ui5) || env.opts.sapui5 || {};
+const escope = require("escope");
 
 /* ---- logging ---- */
 
@@ -115,6 +116,9 @@ let docletUid = 0;
 
 let currentProgram;
 
+// Scope Manager
+let scopeManager;
+
 /**
  * Information about the current module.
  *
@@ -255,25 +259,33 @@ function analyzeModuleDefinition(node) {
 		currentModule.dependencies = convertValue(args[arg], "string[]");
 		arg++;
 	}
-	if ( arg < args.length && 
+	if ( arg < args.length &&
 		[Syntax.FunctionExpression, Syntax.ArrowFunctionExpression].includes(args[arg].type)) {
 
 		currentModule.factory = args[arg];
 		arg++;
 	}
+
 	if ( currentModule.dependencies && currentModule.factory ) {
 		for ( let i = 0; i < currentModule.dependencies.length && i < currentModule.factory.params.length; i++ ) {
-			const name =
-				(currentModule.factory.params[i].type === Syntax.ObjectPattern)
-					? currentModule.factory.params[i].properties[0].value.name // ObjectPattern means destructuring of the parameter
-					: currentModule.factory.params[i].name; // simple Identifier
+			let names = [];
 
-			const module = resolveModuleName(currentModule.module, currentModule.dependencies[i]);
-			debug(`  import ${name} from '${module}'`);
-			currentModule.localNames[name] = {
-				module: module
-				// no (or empty) path
-			};
+			if	( [Syntax.ObjectPattern, Syntax.ArrayPattern].includes(currentModule.factory.params[i].type) ) { // ObjectPattern/ArrayPattern means destructuring of the parameter of a function
+				names = resolveObjectPatternChain(currentModule.factory.params[i], null, []);
+
+			} else if (currentModule.factory.params[i].type === Syntax.Identifier) { // simple Identifier
+				names = [{original: currentModule.factory.params[i].name}];
+			}
+
+			names.forEach(name => {
+				const module = resolveModuleName(currentModule.module, currentModule.dependencies[i]);
+				debug(`  import ${name.renamed || name.original} from '${module}'`);
+
+				currentModule.localNames[name.renamed || name.original] = {
+					module: module,
+					...(name.path ? {path: name.path} : {})
+				};
+			});
 		}
 	}
 	if ( currentModule.factory ) {
@@ -460,7 +472,7 @@ function createPropertyMap(node, defaultKey) {
 
 /**
  * Resolves potential wrapper expressions like: ChainExpression, AwaitExpression, etc.
- * @param {Node} node 
+ * @param {Node} node
  * @returns {Node} the resolved node
  */
 function resolvePotentialWrapperExpression(node) {
@@ -484,9 +496,9 @@ function resolvePotentialWrapperExpression(node) {
 
 /**
  * Strips the ChainExpression wrapper if such
- * 
- * @param {Node} rootNode 
- * @param {String} path 
+ *
+ * @param {Node} rootNode
+ * @param {String} path
  * @returns {Node}
  */
 function stripChainWrappers(rootNode, path) {
@@ -507,16 +519,17 @@ function stripChainWrappers(rootNode, path) {
 
 function isTemplateLiteralWithoutExpression(node) {
 	return (
-		node?.type === Syntax.TemplateLiteral &&
-		node?.expressions?.length === 0 &&
-		node?.quasis?.length === 1
+		node &&
+		node.type === Syntax.TemplateLiteral &&
+		node.expressions && node.expressions.length === 0 &&
+		node.quasis && node.quasis.length === 1
 	);
 }
 
 /**
  * Checks whether a node is Literal or TemplateLiteral without an expression
- * 
- * @param {Node} node 
+ *
+ * @param {Node} node
  * @returns {String}
  */
 function isStringLiteral(node) {
@@ -563,8 +576,8 @@ function isArrowFuncExpression(node) {
 
 /**
  * Checks whether the node is of a "returning" type
- * 
- * @param {Node} node 
+ *
+ * @param {Node} node
  * @returns {Boolean}
  */
 function isReturningNode(node) {
@@ -642,6 +655,254 @@ function isPotentialEnum(node) {
 	return node.properties.every((prop) => isCompileTimeConstant(prop.value));
 }
 
+// ---- ES6+ Destructuring ---------------------------------------------------------
+
+/**
+ * Resolves (nested) Object/ArrayPattern nodes and builds a "path"
+ *
+ * @param {Node} valueNode
+ * @param {Node} keyNode
+ * @param {Array<String>} keyChain
+ * @returns Array<Object<Node, Node, Array<String>>>
+ */
+function resolveObjectPatternChain (valueNode, keyNode, keyChain) {
+	let chainSequence = [];
+
+	if (valueNode && valueNode.type === Syntax.ObjectPattern) {
+		for (let i = 0; i < valueNode.properties.length; i++) {
+			chainSequence = chainSequence.concat(
+				resolveObjectPatternChain(
+					valueNode.properties[i].value,
+					valueNode.properties[i].key,
+					[...keyChain, valueNode.properties[i].key.name] )
+			);
+		}
+	} else if (valueNode && valueNode.type === Syntax.ArrayPattern) {
+		for (let i = 0; i < valueNode.elements.length; i++) {
+			chainSequence = chainSequence.concat(
+				resolveObjectPatternChain(
+					valueNode.elements[i],
+					valueNode.elements[i],
+					[...keyChain, String(i)]
+				)
+			);
+		}
+	} else {
+
+		let result = { original: keyNode.name, path: keyChain.join(".") };
+
+		if (keyNode.name !== valueNode.name) {
+			// Renaming
+			result.renamed = valueNode.name;
+		}
+
+		chainSequence.push(result);
+	}
+
+	return chainSequence;
+}
+
+/**
+ * Tries to resolve an ENUM, regardless where it is defined and being destructured.
+ *
+ * @param {Node} node
+ * @param {String} type
+ * @returns {Object}
+ */
+function resolvePotentialEnum(node, type) {
+	let value = resolveFullyQuantifiedName(node);
+
+	if ( value.startsWith(type + ".") ) {
+		// starts with fully qualified enum name -> cut off name
+		value = value.slice(type.length + 1);
+		return {
+			value: value,
+			raw: value
+		};
+	}
+}
+
+/**
+ * Returns the {Node} of the destructured argument of a (arrow) function.
+ *
+ * @param {Definition|ParameterDefinition} varDefinition
+ * @returns {Node}
+ */
+function getFuncArgumentDestructNode(varDefinition) {
+	if (
+		[
+			Syntax.ArrowFunctionExpression,
+			Syntax.FunctionDeclaration,
+			Syntax.FunctionExpression,
+		].includes(varDefinition.node.type)
+	) {
+		return varDefinition.node.params[varDefinition.index];
+	}
+
+	// return undefined;
+}
+
+/**
+ * Checks whether a variable has been destructured.
+ *
+ * @param {Variable} variable
+ * @returns
+ */
+function isVarDestructuring(variable) {
+	const defNode =
+		variable &&
+		variable.defs &&
+		( getFuncArgumentDestructNode(variable.defs[0]) // (arrow) function argument
+		|| variable.defs[0].node.id ); // variable definition
+
+	return defNode && [Syntax.ObjectPattern, Syntax.ArrayPattern].includes( defNode.type );
+}
+
+/**
+ * Checks whether a var has been renamed while destructuring i.e. {A: b} = SomeObject
+ *
+ * @param {Variable} variable
+ * @returns {Object}
+ */
+function checkVarRenaming(variable) {
+	// variable.defs[0].node.id.type === Syntax.ObjectPattern -> Renaming
+	// variable.defs[0].node.id.properties[0].key.name === variable.name; // Original
+	// variable.defs[0].node.id.properties[0].value.name === variable.name; // Renamed
+
+	// If variable.defs (Variable definitions within the source code) are more 1, then we'd not be able to
+	// determine which defintion to use. For example:
+	//  function doSomething({a}, b) {
+	//		console.log(a);
+	//		var { c : a } = { b };
+	//		console.log(a);
+	//  }
+	//  doSomething({a:42}, 5);
+	//
+	// So, we'd not able to analyze which "a" to which console.log to map
+	if (
+		!variable
+		|| !variable.defs
+		|| variable.defs.length !== 1
+	) {
+		return null;
+	}
+
+	const varDefinition = variable.defs[0];
+	const defNode = getFuncArgumentDestructNode(varDefinition) // (arrow) function argument
+		|| varDefinition.node.id; // variable definition
+
+	return resolveObjectPatternChain(defNode, null, []).find(
+		({ original, renamed }) =>
+			renamed === variable.name || original === variable.name
+	);
+}
+
+/**
+ * Builds the fully quantified name when there's a destructuring of a variable
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+function resolveFullyQuantifiedName(node) {
+	// The missing part is on the left side. The right side is clear.
+	// We would eiter ways resolve to the same leftmost token.
+	let leftMostName = getLeftmostName(node);
+	let originalName = getObjectName(node) || "";
+	const currentScope = getEnclosingVariableScope(node);
+
+	if (!currentScope) {
+		return "";
+	}
+
+	while (leftMostName) {
+		const curVar = currentScope.set.get(leftMostName);
+
+		if (!curVar) {
+			break;
+		}
+
+		if ( !isVarDestructuring(curVar) ) {
+			// Not a destructuring
+			return getResolvedName(originalName, leftMostName);
+		}
+
+		const potentialRenaming = checkVarRenaming(curVar);
+		if (potentialRenaming) {
+			let renamedChunks = originalName.split(".");
+			renamedChunks = getResolvedName( originalName, renamedChunks[0] ).split(".");
+
+			// when getResolvedName() was not able to resolve the renaming of a variable
+			// with currentModule.localNames[].path i.e. in "chained" destructuring, where
+			// the variable is not within localNames registry
+			if ( potentialRenaming.renamed === renamedChunks[0] ) { // Checks for direct renaming
+				renamedChunks[0] = potentialRenaming.original;
+			}
+			// Considers the 'path' if it differs from the original name i.e. there's some namespace before it
+			if ( potentialRenaming.original === renamedChunks[0] && potentialRenaming.path !== potentialRenaming.original ) {
+				renamedChunks[0] = potentialRenaming.path;
+			}
+
+			originalName = renamedChunks.join(".");
+		}
+
+		const writeExpr = curVar.references.filter((ref) => ref.writeExpr);
+
+		// The same case as variable.defs- we're not able to determine the correct chain in case of multiple writeExpr
+		if (writeExpr.length !== 1) {
+			// writeExpr.length === 0 means an function argument and then we need
+			// just to return the already build originalName
+			return writeExpr.length === 0 ? originalName : "";
+		}
+
+		const writeExprNode = writeExpr[0].writeExpr;
+
+		if ( writeExprNode.type === Syntax.MemberExpression && !writeExprNode.computed && writeExprNode.object.type === Syntax.Identifier ) {
+			leftMostName = writeExprNode.object.name;
+
+		} else if (writeExprNode.type === Syntax.MemberExpression && writeExprNode.object.type === Syntax.MemberExpression) { // Standalone variable without leading dot notation namespace
+			leftMostName = getResolvedObjectName(writeExprNode);
+
+		} else if (writeExprNode.type === Syntax.Identifier) {
+			leftMostName = writeExprNode.name;
+
+		} else {
+			leftMostName = "";
+		}
+
+		if (leftMostName) {
+			originalName = leftMostName + "." + originalName;
+		}
+	}
+
+	return originalName;
+}
+
+/**
+ * Gets enclosing scope
+ *
+ * @param {Node} node
+ * @returns {Scope}
+ */
+ function getEnclosingVariableScope (node) {
+	// Get to the nearest upper scope
+	let nearestScopeableNode = node;
+	let nearestScope = scopeManager.acquire(nearestScopeableNode);
+	while (
+		!nearestScope &&
+		nearestScopeableNode &&
+		nearestScopeableNode.parent
+	) {
+		nearestScopeableNode = nearestScopeableNode.parent;
+		nearestScope = scopeManager.acquire(nearestScopeableNode);
+	}
+
+	// FunctionExpression with a name hold the value of the name in its scope.
+	// So, we need to unwrap to get to the real scope with var definitions
+	return nearestScope.functionExpressionScope
+		? nearestScope.childScopes[0]
+		: nearestScope;
+}
+
 function isCompileTimeConstant(node) {
 	return node && node.type === Syntax.Literal;
 }
@@ -674,6 +935,11 @@ function getLeftmostName(node) {
 function getResolvedObjectName(node) {
 	const name = getObjectName(node);
 	const _import = getLeftmostName(node);
+
+	return getResolvedName(name, _import);
+}
+
+function getResolvedName(name, _import) {
 	const local = _import && currentModule.localNames[_import];
 	if ( name && local && (local.class || local.module) ) {
 		let resolvedName;
@@ -733,18 +999,12 @@ function convertValueWithRaw(node, type, propertyName) {
 	} else if ( isMemberExpression(node) && type ) {
 
 		// enum value (a.b.c)
-		value = getResolvedObjectName(node);
-		if ( value.indexOf(type + ".") === 0 ) {
-			// starts with fully qualified enum name -> cut off name
-			value = value.slice(type.length + 1);
-			return {
-				value: value,
-				raw: value
-			};
-//		} else if ( value.indexOf(type.split(".").slice(-1)[0] + ".") === 0 ) {
-//			// unqualified name might be a local name (just a guess - would need static code analysis for proper solution)
-//			return value.slice(type.split(".").slice(-1)[0].length + 1);
+		const potentialEnum = resolvePotentialEnum(node, type);
+
+		if ( potentialEnum ) {
+			return potentialEnum;
 		} else {
+			value = getResolvedObjectName(node);
 			warning(`did not understand default value '${value}'${propertyName ? " of property '" + propertyName + "'" : ""}, falling back to source`);
 			let raw = value;
 			if ( currentSource && node.range ) {
@@ -772,6 +1032,15 @@ function convertValueWithRaw(node, type, propertyName) {
 				raw: local.raw
 			};
 		}
+
+		// This could be an ENUM which has been destructured up to the enum value part. In that case the node.type === Syntax.Identifier
+		// For example, the `Solid` const in the following snippet:
+		// sap.ui.define(["sap/m/library"], ( { BackgroundDesign } ) => {
+		// 	const { Solid } = BackgroundDesign;
+		const potentialEnum = resolvePotentialEnum(node, type);
+		if ( potentialEnum ) {
+			return potentialEnum;
+		}
 	} else if ( node.type === Syntax.ArrayExpression ) {
 
 		if ( node.elements.length === 0 ) {
@@ -801,9 +1070,11 @@ function convertValueWithRaw(node, type, propertyName) {
 		}
 
 	} else if ( isTemplateLiteralWithoutExpression(node) ) {
+		let value = node.quasis[0].value || {};
+
 		return {
-			value: node?.quasis?.[0]?.value?.cooked,
-			raw: node?.quasis?.[0]?.value?.raw,
+			value: value.cooked,
+			raw: value.raw,
 		};
 	}
 
@@ -1229,16 +1500,16 @@ function determineValueRange(expression, varname, inverse) {
 		 && expression.left.type === Syntax.BinaryExpression
 		 && expression.right.type === Syntax.BinaryExpression ) {
 
-			if ( expression.operator === "&&" 
-				&& determineValueRangeBorder(range, expression.left, varname, inverse) 
+			if ( expression.operator === "&&"
+				&& determineValueRangeBorder(range, expression.left, varname, inverse)
 				&& determineValueRangeBorder(range, expression.right, varname, inverse) ) {
 				return range;
 			} else if ( ["||", "??"].includes(expression.operator)
-				&& ( determineValueRangeBorder(range, expression.left, varname, inverse) 
+				&& ( determineValueRangeBorder(range, expression.left, varname, inverse)
 				|| determineValueRangeBorder(range, expression.right, varname, inverse) )) {
 				return range;
 			}
-		
+
 	} else if ( expression.type === Syntax.BinaryExpression
 				&& determineValueRangeBorder(range, expression, varname, inverse) ) {
 		return range;
@@ -2495,6 +2766,7 @@ exports.handlers = {
 			e.doclet.meta.__shortpath = getRelativePath(filepath);
 			_ui5data.resource = currentModule.resource;
 			_ui5data.module = currentModule.name || currentModule.module;
+			_ui5data.initialLongname = e.doclet.longname;
 
 			const localDecl = findLocalDeclaration(e.doclet.meta.lineno, e.doclet.meta.columnno);
 			if ( localDecl ) {
@@ -2694,6 +2966,7 @@ exports.astNodeVisitor = {
 
 		if ( node.type === Syntax.Program ) {
 			currentProgram = node;
+			scopeManager = escope.analyze(currentProgram);
 		}
 
 		function processExtendCall(extendCall, comment, commentAlreadyProcessed) {
@@ -2855,7 +3128,7 @@ exports.astNodeVisitor = {
 	 * to retain the full record type structure.
 	 *
 	 * JSDoc is copyright (c) 2011-present Michael Mathews micmath@gmail.com and the contributors to JSDoc.
-	 */ 
+	 */
 	function getTypeStrings(parsedType, isOutermostType) {
 		let applications;
 		let typeString;
@@ -2960,11 +3233,11 @@ exports.astNodeVisitor = {
 		// #### BEGIN: MODIFIED BY SAP
 		if ( tagInfo && (/function/.test(tagInfo.typeExpression) || /\{.*\}/.test(tagInfo.typeExpression)) && tagInfo.parsedType ) {
 			// #### END: MODIFIED BY SAP
-			// console.info("old typeExpression", tagInfo.typeExpression); 
-			// console.info("old parse tree", tagInfo.parsedType); 
-			// console.info("old parse result", tagInfo.type); 
+			// console.info("old typeExpression", tagInfo.typeExpression);
+			// console.info("old parse tree", tagInfo.parsedType);
+			// console.info("old parse result", tagInfo.type);
 			tagInfo.type = getTypeStrings(tagInfo.parsedType);
-			// console.info("new parse result", tagInfo.type); 
+			// console.info("new parse result", tagInfo.type);
 		}
 		return tagInfo;
 	}

package/lib/processors/jsdoc/lib/ui5/template/publish.cjs

@@ -2877,7 +2877,11 @@ function createAPIJSON4Symbol(symbol, omitDefaults) {
 		}
 		tag("method");
 		attrib("name", name || member.name);
-		if ( member.__ui5.module && member.__ui5.module !== symbol.__ui5.module ) {
+		// write out module and export only when the module is different from the module of the parent entity
+		// and when the member was not cloned (e.g. because it is borrowed)
+		if ( member.__ui5.module
+			 && member.__ui5.module !== symbol.__ui5.module
+			 && member.__ui5.initialLongname === member.longname ) {
 			attrib("module", member.__ui5.module);
 			attrib("export", member.__ui5.globalOnly ? GLOBAL_ONLY : member.__ui5.export, '', true);
 		}

package/lib/processors/libraryLessGenerator.js

@@ -178,7 +178,7 @@ class LibraryLessGenerator {
  * @param {@ui5/fs/Resource[]} parameters.resources List of <code>library.source.less</code>
  * resources
  * @param {fs|module:@ui5/fs/fsInterface} parameters.fs Node fs or custom
- * [fs interface]{@link module:resources/module:@ui5/fs/fsInterface}
+ * [fs interface]{@link module:@ui5/fs/fsInterface}
  * @returns {Promise<@ui5/fs/Resource[]>} Promise resolving with library.less resources
  */
 async function createLibraryLess({resources, fs}) {

package/lib/processors/manifestCreator.js

@@ -349,7 +349,7 @@ async function createManifest(
 		}
 
 		function collectThemes() {
-			const themes = {};
+			const themes = Object.create(null);
 
 			// find theme resources and determine theme names from their paths
 			libBundle.getResources(/(?:[^/]+\/)*themes\//).forEach((res) => {

package/lib/processors/nonAsciiEscaper.js

@@ -14,7 +14,7 @@ import escapeUnicode from "escape-unicode";
 const CHAR_CODE_OF_LAST_ASCII_CHARACTER = 127;
 
 // use memoization for escapeUnicode function for performance
-const memoizeEscapeUnicodeMap = {};
+const memoizeEscapeUnicodeMap = Object.create(null);
 const memoizeEscapeUnicode = function(sChar) {
 	if (memoizeEscapeUnicodeMap[sChar]) {
 		return memoizeEscapeUnicodeMap[sChar];

package/lib/processors/versionInfoGenerator.js

@@ -25,7 +25,7 @@ function getTimestamp() {
 /**
  * Manifest libraries as defined in the manifest.json file
  *
- * @typedef {object<string, {lazy: boolean}>} ManifestLibraries
+ * @typedef {Object<string, {lazy: boolean}>} ManifestLibraries
  *
  * sample:
  * <pre>
@@ -60,15 +60,15 @@ function getTimestamp() {
 const processManifest = async (manifestResource) => {
 	const manifestContent = await manifestResource.getString();
 	const manifestObject = JSON.parse(manifestContent);
-	const manifestInfo = {};
+	const manifestInfo = Object.create(null);
 
 	// sap.ui5/dependencies is used for the "manifestHints/libs"
 	if (manifestObject["sap.ui5"]) {
 		const manifestDependencies = manifestObject["sap.ui5"]["dependencies"];
 		if (manifestDependencies && manifestDependencies.libs) {
-			const libs = {};
+			const libs = Object.create(null);
 			for (const [libKey, libValue] of Object.entries(manifestDependencies.libs)) {
-				libs[libKey] = {};
+				libs[libKey] = Object.create(null);
 				if (libValue.lazy) {
 					libs[libKey].lazy = true;
 				}
@@ -230,7 +230,7 @@ class DependencyInfo {
  * @returns {object} the object with sorted keys
  */
 const sortObjectKeys = (obj) => {
-	const sortedObject = {};
+	const sortedObject = Object.create(null);
 	const keys = Object.keys(obj);
 	keys.sort();
 	keys.forEach((key) => {
@@ -433,7 +433,7 @@ export default async function({options}) {
 	let components;
 	artifactInfos.forEach((artifactInfo) => {
 		artifactInfo.embeds.forEach((embeddedArtifactInfo) => {
-			const componentObject = {};
+			const componentObject = Object.create(null);
 			const bundledComponents = artifactInfo.bundledComponents;
 			const componentName = embeddedArtifactInfo.componentName;
 			if (!bundledComponents.has(componentName)) {
@@ -446,7 +446,7 @@ export default async function({options}) {
 				componentObject.manifestHints = manifestHints;
 			}
 
-			components = components || {};
+			components = components || Object.create(null);
 			components[componentName] = componentObject;
 		});
 	});

package/lib/tasks/bundlers/generateBundle.js

@@ -87,8 +87,11 @@ export default async function({
 		// Omit -dbg files for optimize bundles and vice versa
 		const filterTag = optimize ?
 			taskUtil.STANDARD_TAGS.IsDebugVariant : taskUtil.STANDARD_TAGS.HasDebugVariant;
-		combo = await combo.filter(function(resource) {
-			return !taskUtil.getTag(resource, filterTag);
+		combo = taskUtil.resourceFactory.createFilterReader({
+			reader: combo,
+			callback: function(resource) {
+				return !taskUtil.getTag(resource, filterTag);
+			}
 		});
 	}
 

package/lib/tasks/bundlers/generateComponentPreload.js

@@ -37,9 +37,12 @@ export default async function({
 }) {
 	let nonDbgWorkspace = workspace;
 	if (taskUtil) {
-		nonDbgWorkspace = await workspace.filter(function(resource) {
-			// Remove any debug variants
-			return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant);
+		nonDbgWorkspace = taskUtil.resourceFactory.createFilterReader({
+			reader: workspace,
+			callback: function(resource) {
+				// Remove any debug variants
+				return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant);
+			}
 		});
 	}
 

package/lib/tasks/bundlers/generateLibraryPreload.js

@@ -246,9 +246,12 @@ function getSapUiCoreBunDef(name, filters, preload) {
 export default async function({workspace, taskUtil, options: {skipBundles = [], excludes = [], projectName}}) {
 	let nonDbgWorkspace = workspace;
 	if (taskUtil) {
-		nonDbgWorkspace = await workspace.filter(function(resource) {
-			// Remove any debug variants
-			return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant);
+		nonDbgWorkspace = taskUtil.resourceFactory.createFilterReader({
+			reader: workspace,
+			callback: function(resource) {
+				// Remove any debug variants
+				return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant);
+			}
 		});
 	}
 
@@ -273,7 +276,7 @@ export default async function({workspace, taskUtil, options: {skipBundles = [],
 			// This is mainly to have an easier check without version parsing or using semver.
 			// If no project/specVersion is available, the bundles should also be created to not break potential
 			// existing use cases without a properly formed/formatted project tree.
-			if (!taskUtil || ["0.1", "1.1", "2.0"].includes(taskUtil.getProject().getSpecVersion())) {
+			if (!taskUtil || taskUtil.getProject().getSpecVersion().lte("2.0")) {
 				const isEvo = resources.find((resource) => {
 					return resource.getPath() === "/resources/ui5loader.js";
 				});
@@ -281,9 +284,12 @@ export default async function({workspace, taskUtil, options: {skipBundles = [],
 				let unoptimizedModuleNameMapping;
 				let unoptimizedResources = resources;
 				if (taskUtil) {
-					const unoptimizedWorkspace = await workspace.filter(function(resource) {
-						// Remove any non-debug variants
-						return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.HasDebugVariant);
+					const unoptimizedWorkspace = taskUtil.resourceFactory.createFilterReader({
+						reader: workspace,
+						callback: function(resource) {
+							// Remove any non-debug variants
+							return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.HasDebugVariant);
+						}
 					});
 					unoptimizedResources =
 						await unoptimizedWorkspace.byGlob("/**/*.{js,json,xml,html,properties,library,js.map}");

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

@@ -15,7 +15,7 @@ import {getNonDebugName} from "../../../lbt/utils/ModuleName.js";
  * @returns {object} Module name mapping
  */
 export default function({resources, taskUtil}) {
-	const moduleNameMapping = {};
+	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)) {

package/lib/tasks/generateCachebusterInfo.js

@@ -57,7 +57,7 @@ export default function({workspace, options}) {
 	const basePath = `/resources/${namespace}/`;
 	return workspace.byGlob(`/resources/${namespace}/**/*`)
 		.then(async (resources) => {
-			const cachebusterInfo = {};
+			const cachebusterInfo = Object.create(null);
 			const signer = getSigner(signatureType);
 
 			await Promise.all(resources.map(async (resource) => {

package/lib/tasks/taskRepository.js

@@ -11,7 +11,6 @@ const taskInfos = {
 	transformBootstrapHtml: {path: "./transformBootstrapHtml.js"},
 	generateLibraryManifest: {path: "./generateLibraryManifest.js"},
 	generateVersionInfo: {path: "./generateVersionInfo.js"},
-	generateManifestBundle: {path: "./bundlers/generateManifestBundle.js"},
 	generateFlexChangesBundle: {path: "./bundlers/generateFlexChangesBundle.js"},
 	generateComponentPreload: {path: "./bundlers/generateComponentPreload.js"},
 	generateResourcesJson: {path: "./generateResourcesJson.js"},
@@ -26,7 +25,7 @@ export async function getTask(taskName) {
 	const taskInfo = taskInfos[taskName];
 
 	if (!taskInfo) {
-		if (["createDebugFiles", "uglify"].includes(taskName)) {
+		if (["createDebugFiles", "uglify", "generateManifestBundle"].includes(taskName)) {
 			throw new Error(
 				`Standard task ${taskName} has been removed in UI5 Tooling 3.0. ` +
 				`Please see the migration guide at https://sap.github.io/ui5-tooling/updates/migrate-v3/`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ui5/builder",
-	"version": "3.0.0-beta.1",
+	"version": "3.0.0-beta.3",
 	"description": "UI5 Tooling - Builder",
 	"author": {
 		"name": "SAP SE",
@@ -28,7 +28,7 @@
 		"./internal/jsdoc/template/publish": "./lib/processors/jsdoc/lib/ui5/template/publish.cjs"
 	},
 	"engines": {
-		"node": ">= 16.13.2",
+		"node": "^16.18.0 || >=18.0.0",
 		"npm": ">= 8"
 	},
 	"scripts": {
@@ -119,44 +119,42 @@
 	},
 	"dependencies": {
 		"@jridgewell/sourcemap-codec": "^1.4.14",
-		"@ui5/fs": "^3.0.0-beta.2",
-		"@ui5/logger": "^3.0.1-beta.0",
-		"cheerio": "1.0.0-rc.9",
+		"@ui5/fs": "^3.0.0-beta.3",
+		"@ui5/logger": "^3.0.1-beta.1",
+		"cheerio": "1.0.0-rc.12",
 		"escape-unicode": "^0.2.0",
 		"escope": "^4.0.0",
-		"espree": "^9.3.1",
-		"graceful-fs": "^4.2.9",
-		"jsdoc": "^3.6.7",
+		"espree": "^9.4.1",
+		"graceful-fs": "^4.2.10",
+		"jsdoc": "^3.6.11",
 		"less-openui5": "^0.11.2",
 		"make-dir": "^3.1.0",
 		"pretty-data": "^0.40.0",
 		"replacestream": "^4.0.3",
 		"rimraf": "^3.0.2",
-		"semver": "^7.3.5",
-		"terser": "^5.14.2",
-		"xml2js": "^0.4.23",
-		"yazl": "^2.5.1"
+		"semver": "^7.3.8",
+		"terser": "^5.16.0",
+		"xml2js": "^0.4.23"
 	},
 	"devDependencies": {
 		"@istanbuljs/esm-loader-hook": "^0.2.0",
-		"@ui5/project": "^3.0.0-alpha.10",
-		"ava": "^4.3.3",
-		"chai": "^4.3.4",
+		"@ui5/project": "^3.0.0-beta.3",
+		"ava": "^5.1.0",
+		"chai": "^4.3.7",
 		"chai-fs": "^2.0.0",
 		"chokidar-cli": "^3.0.0",
 		"cross-env": "^7.0.3",
 		"depcheck": "^1.4.3",
-		"docdash": "^1.2.0",
-		"eslint": "^8.26.0",
+		"docdash": "^2.0.0",
+		"eslint": "^8.28.0",
 		"eslint-config-google": "^0.14.0",
 		"eslint-plugin-ava": "^13.2.0",
-		"eslint-plugin-jsdoc": "^37.6.3",
-		"esmock": "^2.0.1",
-		"extract-zip": "^2.0.1",
+		"eslint-plugin-jsdoc": "^39.6.4",
+		"esmock": "^2.0.9",
 		"nyc": "^15.1.0",
 		"open-cli": "^7.1.0",
 		"recursive-readdir": "^2.2.3",
-		"sinon": "^14.0.0",
+		"sinon": "^14.0.2",
 		"tap-nyan": "^1.1.0",
 		"tap-xunit": "^2.4.1"
 	}

package/lib/processors/bundlers/manifestBundler.js

@@ -1,181 +0,0 @@
-import posixPath from "node:path/posix";
-import yazl from "yazl";
-import {createResource} from "@ui5/fs/resourceFactory";
-import logger from "@ui5/logger";
-const log = logger.getLogger("builder:processors:bundlers:manifestBundler");
-
-/**
- * Repository to handle i18n resource files
- *
- * @private
- */
-class I18nResourceList {
-	/**
-	 * Constructor
-	 */
-	constructor() {
-		this.propertyFiles = new Map();
-	}
-
-	/**
-	 * Adds a i18n resource to the repository
-	 *
-	 * @param {string} directory Path to the i18n resource
-	 * @param {@ui5/fs/Resource} resource i18n resource
-	 */
-	add(directory, resource) {
-		const normalizedDirectory = posixPath.normalize(directory);
-		if (!this.propertyFiles.has(normalizedDirectory)) {
-			this.propertyFiles.set(normalizedDirectory, [resource]);
-		} else {
-			this.propertyFiles.get(normalizedDirectory).push(resource);
-		}
-	}
-
-	/**
-	 * Gets all registered i18n files within the provided path
-	 *
-	 * @param {string} directory Path to search for
-	 * @returns {Array} Array of resources files
-	 */
-	get(directory) {
-		return this.propertyFiles.get(posixPath.normalize(directory)) || [];
-	}
-}
-
-
-/**
- * @public
- * @module @ui5/builder/processors/bundlers/manifestBundler
- */
-
-/**
- * Creates a manifest bundle from the provided resources.
- *
- * @public
- * @function default
- * @static
- *
- * @param {object} parameters Parameters
- * @param {@ui5/fs/Resource[]} parameters.resources List of resources to be processed
- * @param {object} parameters.options Options
- * @param {string} parameters.options.namespace Namespace of the project
- * @param {string} parameters.options.bundleName Name of the bundled zip file
- * @param {string} parameters.options.propertiesExtension Extension name of the properties files, e.g. ".properties"
- * @param {string} parameters.options.descriptor Descriptor name
- * @returns {Promise<@ui5/fs/Resource[]>} Promise resolving with manifest bundle resources
- */
-export default ({resources, options: {namespace, bundleName, propertiesExtension, descriptor}}) => {
-	function bundleNameToUrl(bundleName, appId) {
-		if (!bundleName.startsWith(appId)) {
-			return null;
-		}
-		const relativeBundleName = bundleName.substring(appId.length + 1);
-		return relativeBundleName.replace(/\./g, "/") + propertiesExtension;
-	}
-
-	function addDescriptorI18nInfos(descriptorI18nInfos, manifest) {
-		function addI18nInfo(i18nPath) {
-			if (i18nPath.startsWith("ui5:")) {
-				log.warn(`Using the ui5:// protocol for i18n bundles is currently not supported ('${i18nPath}' in ${manifest.path})`);
-				return;
-			}
-			descriptorI18nInfos.set(
-				posixPath.join(posixPath.dirname(manifest.path), posixPath.dirname(i18nPath)),
-				posixPath.basename(i18nPath, propertiesExtension)
-			);
-		}
-
-		const content = JSON.parse(manifest.content);
-		const appI18n = content["sap.app"]["i18n"];
-		let bundleUrl;
-		// i18n section in sap.app can be either a string or an object with bundleUrl
-		if (typeof appI18n === "object") {
-			if (appI18n.bundleUrl) {
-				bundleUrl = appI18n.bundleUrl;
-			} else if (appI18n.bundleName) {
-				bundleUrl = bundleNameToUrl(appI18n.bundleName, content["sap.app"]["id"]);
-			}
-		} else if (typeof appI18n === "string") {
-			bundleUrl = appI18n;
-		} else {
-			bundleUrl = "i18n/i18n.properties";
-		}
-		if (bundleUrl) {
-			addI18nInfo(bundleUrl);
-		}
-
-		if (typeof appI18n === "object" && Array.isArray(appI18n.enhanceWith)) {
-			appI18n.enhanceWith.forEach((enhanceWithEntry) => {
-				let bundleUrl;
-				if (enhanceWithEntry.bundleUrl) {
-					bundleUrl = enhanceWithEntry.bundleUrl;
-				} else if (enhanceWithEntry.bundleName) {
-					bundleUrl = bundleNameToUrl(enhanceWithEntry.bundleName, content["sap.app"]["id"]);
-				}
-				if (bundleUrl) {
-					addI18nInfo(bundleUrl);
-				}
-			});
-		}
-	}
-
-	return Promise.all(resources.map((resource) =>
-		resource.getBuffer().then((content) => {
-			const basename = posixPath.basename(resource.getPath());
-			return {
-				name: basename,
-				isManifest: basename === descriptor,
-				path: resource.getPath(),
-				content: content
-			};
-		})
-	)).then((resources) => {
-		const archiveContent = new Map();
-		const descriptorI18nInfos = new Map();
-		const i18nResourceList = new I18nResourceList();
-
-		resources.forEach((resource) => {
-			if (resource.isManifest) {
-				addDescriptorI18nInfos(descriptorI18nInfos, resource);
-				archiveContent.set(resource.path, resource.content);
-			} else {
-				const directory = posixPath.dirname(resource.path);
-				i18nResourceList.add(directory, resource);
-			}
-		});
-
-		descriptorI18nInfos.forEach((rootName, directory) => {
-			const i18nResources = i18nResourceList.get(directory)
-				.filter((resource) => resource.name.startsWith(rootName));
-
-			if (i18nResources.length) {
-				i18nResources.forEach((resource) => archiveContent.set(resource.path, resource.content));
-			} else {
-				log.warn(`Could not find any resources for i18n bundle '${directory}'`);
-			}
-		});
-
-		return archiveContent;
-	}).then((archiveContent) => new Promise((resolve) => {
-		const zip = new yazl.ZipFile();
-		const basePath = `/resources/${namespace}/`;
-		archiveContent.forEach((content, path) => {
-			if (!path.startsWith(basePath)) {
-				log.verbose(`Not bundling resource with path ${path} since it is not based on path ${basePath}`);
-				return;
-			}
-			// Remove base path. Absolute paths are not allowed in ZIP files
-			const normalizedPath = path.replace(basePath, "");
-			zip.addBuffer(content, normalizedPath);
-		});
-		zip.end();
-
-		const pathPrefix = "/resources/" + namespace + "/";
-		const res = createResource({
-			path: pathPrefix + bundleName,
-			stream: zip.outputStream
-		});
-		resolve([res]);
-	}));
-};

package/lib/tasks/bundlers/generateManifestBundle.js

@@ -1,58 +0,0 @@
-import logger from "@ui5/logger";
-const log = logger.getLogger("builder:tasks:bundlers:generateManifestBundle");
-import manifestBundler from "../../processors/bundlers/manifestBundler.js";
-
-const DESCRIPTOR = "manifest.json";
-const PROPERTIES_EXT = ".properties";
-const BUNDLE_NAME = "manifest-bundle.zip";
-
-/**
- * @public
- * @module @ui5/builder/tasks/bundlers/generateManifestBundle
- */
-
-/* eslint "jsdoc/check-param-names": ["error", {"disableExtraPropertyReporting":true}] */
-/**
- * Task for manifestBundler.
- *
- * @public
- * @function default
- * @static
- *
- * @param {object} parameters Parameters
- * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
- * @param {object} parameters.options Options
- * @param {string} parameters.options.projectName Project name
- * @param {string} parameters.options.projectNamespace Project namespace
- * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
- */
-export default async function({workspace, options = {}}) {
-	const {projectName} = options;
-	// Backward compatibility: "namespace" option got renamed to "projectNamespace"
-	const namespace = options.projectNamespace || options.namespace;
-
-	if (!projectName || !namespace) {
-		throw new Error("[generateManifestBundle]: One or more mandatory options not provided");
-	}
-
-	const allResources = await workspace.byGlob(`/resources/${namespace}/**/{${DESCRIPTOR},*${PROPERTIES_EXT}}`);
-	if (allResources.length === 0) {
-		log.verbose(`Could not find a "${DESCRIPTOR}" file for project ${projectName}, ` +
-			`creation of "${BUNDLE_NAME}" is skipped!`);
-		return;
-	}
-
-	const processedResources = await manifestBundler({
-		resources: allResources,
-		options: {
-			descriptor: DESCRIPTOR,
-			propertiesExtension: PROPERTIES_EXT,
-			bundleName: BUNDLE_NAME,
-			namespace
-		}
-	});
-
-	await Promise.all(processedResources.map((resource) => {
-		return workspace.write(resource);
-	}));
-}