@ui5/builder 2.11.4 → 3.0.0-alpha.2

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

@@ -289,7 +289,7 @@ class BundleResolver {
 
 				return collectModulesForSection(section).
 					then( (modules) => {
-						if ( section.mode == SectionType.Raw && section.sort ) {
+						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);

package/lib/lbt/resources/LocatorResource.js

@@ -1,14 +1,12 @@
 const Resource = require("./Resource");
 
-
-function extractName(path) {
-	return path.slice( "/resources/".length);
-}
-
+// 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;
 	}
 
@@ -19,6 +17,10 @@ class LocatorResource extends Resource {
 	getProject() {
 		return this.resource._project;
 	}
+
+	getPath() {
+		return this.resource.getPath();
+	}
 }
 
 module.exports = LocatorResource;

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);
+				}
+				this.addResource(new LocatorResource(this, resource, moduleName));
+			}).filter(Boolean)
 		);
 	}
 }

package/lib/lbt/resources/Resource.js

@@ -18,6 +18,13 @@ class Resource {
 	async buffer() {
 		return readFile(this.file);
 	}
+
+	/**
+	 * @returns {Promise<string>} String of the file content
+	 */
+	async string() {
+		return (await this.buffer()).toString();
+	}
 }
 
 module.exports = Resource;

package/lib/lbt/resources/ResourceCollector.js

@@ -193,17 +193,16 @@ class ResourceCollector {
 	}
 
 	async determineResourceDetails({
-		debugResources, mergedResources, designtimeResources, supportResources, debugBundles
+		debugResources, mergedResources, designtimeResources, supportResources
 	}) {
 		const baseNames = new Set();
 		const debugFilter = new ResourceFilterList(debugResources);
 		const mergeFilter = new ResourceFilterList(mergedResources);
 		const designtimeFilter = new ResourceFilterList(designtimeResources);
 		const supportFilter = new ResourceFilterList(supportResources);
-		const debugBundleFilter = new ResourceFilterList(debugBundles);
 
 		const promises = [];
-		const nonBundledDebugResources = [];
+		const debugResourcesInfo = [];
 
 		for (const [name, info] of this._resources.entries()) {
 			if ( debugFilter.matches(name) ) {
@@ -231,13 +230,14 @@ class ResourceCollector {
 			}
 
 			if ( /(?:\.js|\.view\.xml|\.control\.xml|\.fragment\.xml)$/.test(name) ) {
-				if ( (!info.isDebug || debugBundleFilter.matches(name)) ) {
-					// Only analyze non-debug files and special debug bundles (like sap-ui-core-dbg.js)
+				if ( !info.isDebug ) {
+					// Only analyze non-dbg files in first run
 					promises.push(
 						this.enrichWithDependencyInfo(info)
 					);
 				} else {
-					nonBundledDebugResources.push(info);
+					// Collect dbg files to be handled in a second step (see below)
+					debugResourcesInfo.push(info);
 				}
 			}
 
@@ -279,19 +279,37 @@ class ResourceCollector {
 
 		await Promise.all(promises);
 
-		for (let i = nonBundledDebugResources.length - 1; i >= 0; i--) {
-			const dbgInfo = nonBundledDebugResources[i];
+		const debugBundlePromises = [];
+
+		for (let i = debugResourcesInfo.length - 1; i >= 0; i--) {
+			const dbgInfo = debugResourcesInfo[i];
 			const nonDebugName = ResourceInfoList.getNonDebugName(dbgInfo.name);
 			const nonDbgInfo = this._resources.get(nonDebugName);
-			const newDbgInfo = new ResourceInfo(dbgInfo.name);
-
-			// 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);
 
-			this._resources.set(dbgInfo.name, newDbgInfo);
+			// FIXME: "merged" property is only calculated in ResourceInfo#copyFrom
+			// Therefore using the same logic here to compute it.
+			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)
+				);
+			} 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);
+
+				// 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);
+
+				this._resources.set(dbgInfo.name, newDbgInfo);
+			}
 		}
+
+		await Promise.all(debugBundlePromises);
 	}
 
 	createOrphanFilters() {

package/lib/lbt/utils/parseUtils.js

@@ -9,7 +9,7 @@ function parseJS(code, userOptions = {}) {
 	// allowed options and their defaults
 	const options = {
 		comment: false,
-		ecmaVersion: 2020,
+		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

@@ -89,7 +89,9 @@ const log = require("@ui5/logger").getLogger("builder:processors:bundlers:module
  *
  * @public
  * @typedef {object} ModuleBundleOptions
- * @property {boolean} [optimize=false] If set to 'true' the module bundle gets minified
+ * @property {boolean} [optimize=true] Whether the module bundle gets minified
+ * @property {boolean} [sourceMap] Whether to generate a source map file for the bundle.
+ *   Defaults to true if <code>optimize</code> is set to true
  * @property {boolean} [decorateBootstrapModule=false] If set to 'false', the module won't be decorated
  *   with an optimization marker
  * @property {boolean} [addTryCatchRestartWrapper=false] Whether to wrap bootable module bundles with
@@ -101,23 +103,39 @@ 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
+ * @param {ModuleBundleOptions} [parameters.options.bundleOptions] Module bundle options
+ * @returns {Promise<module:@ui5/builder.processors.MinifierResult[]>} Promise resolving with module bundle resources
  */
-module.exports = function({resources, options: {bundleDefinition, bundleOptions}}) {
-//	console.log("preloadBundler bundleDefinition:");
-//	console.log(JSON.stringify(options.bundleDefinition, null, 4));
-
-	// TODO 3.0: Fix defaulting behavior, align with JSDoc
-	bundleOptions = bundleOptions || {optimize: true};
+module.exports = function({resources, options: {bundleDefinition, bundleOptions, moduleNameMapping}}) {
+	// Apply defaults without modifying the passed object
+	bundleOptions = Object.assign({}, {
+		optimize: true,
+		decorateBootstrapModule: false,
+		addTryCatchRestartWrapper: false,
+		usePredefineCalls: false,
+		numberOfParts: 1,
+		ignoreMissingModules: false
+	}, bundleOptions);
 
 	const pool = new LocatorResourcePool({
 		ignoreMissingModules: bundleOptions.ignoreMissingModules
@@ -130,7 +148,7 @@ module.exports = function({resources, options: {bundleDefinition, bundleOptions}
 		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;
@@ -142,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/minifier.js

@@ -0,0 +1,89 @@
+const path = require("path");
+const terser = require("terser");
+const Resource = require("@ui5/fs").Resource;
+/**
+ * Preserve comments which contain:
+ * <ul>
+ *  <li>copyright notice</li>
+ *  <li>license terms</li>
+ *  <li>"@ui5-bundle"</li>
+ *  <li>"@ui5-bundle-raw-include"</li>
+ * </ul>
+ *
+ * @type {RegExp}
+ */
+const copyrightCommentsAndBundleCommentPattern = /copyright|\(c\)(?:[0-9]+|\s+[0-9A-za-z])|released under|license|\u00a9|^@ui5-bundle-raw-include |^@ui5-bundle /i;
+const debugFileRegex = /((?:\.view|\.fragment|\.controller|\.designtime|\.support)?\.js)$/;
+
+
+/**
+ * Result set
+ *
+ * @public
+ * @typedef {object} MinifierResult
+ * @property {module:@ui5/fs.Resource} resource Minified resource
+ * @property {module:@ui5/fs.Resource} dbgResource Debug (non-minified) variant
+ * @property {module:@ui5/fs.Resource} sourceMap Source Map
+ * @memberof module:@ui5/builder.processors
+ */
+
+/**
+ * Minifies the supplied resources.
+ *
+ * @public
+ * @alias module:@ui5/builder.processors.minifier
+ * @param {object} parameters Parameters
+ * @param {module:@ui5/fs.Resource[]} parameters.resources List of resources to be processed
+ * @param {boolean} [parameters.addSourceMappingUrl=true]
+ * 				Whether to add a sourceMappingURL reference to the end of the minified resource
+ * @returns {Promise<module:@ui5/builder.processors.MinifierResult[]>}
+ * 				Promise resolving with object of resource, dbgResource and sourceMap
+ */
+module.exports = async function({resources, addSourceMappingUrl = true}) {
+	return Promise.all(resources.map(async (resource) => {
+		const dbgPath = resource.getPath().replace(debugFileRegex, "-dbg$1");
+		const dbgResource = await resource.clone();
+		dbgResource.setPath(dbgPath);
+
+		const filename = path.posix.basename(resource.getPath());
+		const code = await resource.getString();
+		try {
+			const sourceMapOptions = {
+				filename
+			};
+			if (addSourceMappingUrl) {
+				sourceMapOptions.url = filename + ".map";
+			}
+			const dbgFilename = path.posix.basename(dbgPath);
+			const result = await terser.minify({
+				// Use debug-name since this will be referenced in the source map "sources"
+				[dbgFilename]: code
+			}, {
+				output: {
+					comments: copyrightCommentsAndBundleCommentPattern,
+					wrap_func_args: false
+				},
+				compress: false,
+				mangle: {
+					reserved: [
+						"jQuery",
+						"jquery",
+						"sap",
+					]
+				},
+				sourceMap: sourceMapOptions
+			});
+			resource.setString(result.code);
+			const sourceMapResource = new Resource({
+				path: resource.getPath() + ".map",
+				string: result.map
+			});
+			return {resource, dbgResource, sourceMapResource};
+		} catch (err) {
+			// 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})`);
+		}
+	}));
+};

package/lib/processors/resourceListCreator.js

@@ -66,17 +66,6 @@ const DEFAULT_SUPPORT_RESOURCES_FILTER = [
 	"**/*.support.js"
 ];
 
-/**
- * Hard coded debug bundle, to trigger separate analysis for this filename
- * because sap-ui-core.js and sap-ui-core-dbg.js have different includes
- *
- * @type {string[]}
- */
-const DEBUG_BUNDLES = [
-	"sap-ui-core-dbg.js",
-	"sap-ui-core-nojQuery-dbg.js"
-];
-
 /**
  * Creates and adds resources.json entry (itself) to the list.
  *
@@ -138,8 +127,7 @@ module.exports = async function({resources, dependencyResources = [], options})
 		debugResources: DEFAULT_DEBUG_RESOURCES_FILTER,
 		mergedResources: DEFAULT_BUNDLE_RESOURCES_FILTER,
 		designtimeResources: DEFAULT_DESIGNTIME_RESOURCES_FILTER,
-		supportResources: DEFAULT_SUPPORT_RESOURCES_FILTER,
-		debugBundles: DEBUG_BUNDLES
+		supportResources: DEFAULT_SUPPORT_RESOURCES_FILTER
 	}, options);
 
 	const pool = new LocatorResourcePool();
@@ -158,12 +146,10 @@ module.exports = async function({resources, dependencyResources = [], options})
 	}
 
 	await collector.determineResourceDetails({
-		pool,
 		debugResources: options.debugResources,
 		mergedResources: options.mergedResources,
 		designtimeResources: options.designtimeResources,
-		supportResources: options.supportResources,
-		debugBundles: options.debugBundles
+		supportResources: options.supportResources
 	});
 
 	// group resources by components and create ResourceInfoLists

package/lib/tasks/TaskUtil.js

@@ -51,14 +51,14 @@ class TaskUtil {
 	 * This method is only available to custom task extensions defining
 	 * <b>Specification Version 2.2 and above</b>.
 	 *
-	 * @param {module:@ui5/fs.Resource} resource The resource the tag should be stored for
+	 * @param {string|module:@ui5/fs.Resource} resourcePath Path or resource-instance the tag should be stored for
 	 * @param {string} tag Name of the tag.
 	 * 		Currently only the [STANDARD_TAGS]{@link module:@ui5/builder.tasks.TaskUtil#STANDARD_TAGS} are allowed
 	 * @param {string|boolean|integer} [value=true] Tag value. Must be primitive
 	 * @public
 	 */
-	setTag(resource, tag, value) {
-		return this._projectBuildContext.getResourceTagCollection().setTag(resource, tag, value);
+	setTag(resourcePath, tag, value) {
+		return this._projectBuildContext.getResourceTagCollection().setTag(resourcePath, tag, value);
 	}
 
 	/**
@@ -68,14 +68,14 @@ class TaskUtil {
 	 * This method is only available to custom task extensions defining
 	 * <b>Specification Version 2.2 and above</b>.
 	 *
-	 * @param {module:@ui5/fs.Resource} resource The resource the tag should be retrieved for
+	 * @param {string|module:@ui5/fs.Resource} resourcePath Path or resource-instance the tag should be retrieved for
 	 * @param {string} tag Name of the tag
 	 * @returns {string|boolean|integer|undefined} Tag value for the given resource.
 	 * 										<code>undefined</code> if no value is available
 	 * @public
 	 */
-	getTag(resource, tag) {
-		return this._projectBuildContext.getResourceTagCollection().getTag(resource, tag);
+	getTag(resourcePath, tag) {
+		return this._projectBuildContext.getResourceTagCollection().getTag(resourcePath, tag);
 	}
 
 	/**
@@ -86,12 +86,12 @@ class TaskUtil {
 	 * This method is only available to custom task extensions defining
 	 * <b>Specification Version 2.2 and above</b>.
 	 *
-	 * @param {module:@ui5/fs.Resource} resource The resource the tag should be cleared for
+	 * @param {string|module:@ui5/fs.Resource} resourcePath Path or resource-instance the tag should be cleared for
 	 * @param {string} tag Tag
 	 * @public
 	 */
-	clearTag(resource, tag) {
-		return this._projectBuildContext.getResourceTagCollection().clearTag(resource, tag);
+	clearTag(resourcePath, tag) {
+		return this._projectBuildContext.getResourceTagCollection().clearTag(resourcePath, tag);
 	}
 
 	/**

package/lib/tasks/bundlers/generateBundle.js

@@ -1,4 +1,5 @@
 const moduleBundler = require("../../processors/bundlers/moduleBundler");
+const ModuleName = require("../../lbt/utils/ModuleName");
 const ReaderCollectionPrioritized = require("@ui5/fs").ReaderCollectionPrioritized;
 
 /**
@@ -13,30 +14,115 @@ const ReaderCollectionPrioritized = require("@ui5/fs").ReaderCollectionPrioritiz
  * @param {object} parameters.options Options
  * @param {string} parameters.options.projectName Project name
  * @param {ModuleBundleDefinition} parameters.options.bundleDefinition Module bundle definition
- * @param {ModuleBundleOptions} parameters.options.bundleOptions Module bundle options
+ * @param {ModuleBundleOptions} [parameters.options.bundleOptions] Module bundle options
  * @returns {Promise} Promise resolving with <code>undefined</code> once data has been written
  */
 module.exports = function({
 	workspace, dependencies, taskUtil, options: {projectName, bundleDefinition, bundleOptions}
 }) {
-	const combo = new ReaderCollectionPrioritized({
+	let combo = new ReaderCollectionPrioritized({
 		name: `libraryBundler - prioritize workspace over dependencies: ${projectName}`,
 		readers: [workspace, dependencies]
 	});
 
-	return combo.byGlob("/resources/**/*.{js,json,xml,html,properties,library}").then((resources) => {
+	const optimize = !bundleOptions || bundleOptions.optimize !== false;
+	if (taskUtil) {
+		/* Scenarios
+			1. Optimize bundle with minification already done
+				Workspace:
+					* /resources/my/lib/Control.js 				[ui5:HasDebugVariant]
+					* /resources/my/lib/Control.js.map 			[ui5:HasDebugVariant]
+					* /resources/my/lib/Control-dbg.js 			[ui5:IsDebugVariant]
+
+				Bundler input:
+					* /resources/my/lib/Control.js
+					* /resources/my/lib/Control.js.map
+
+				=> Filter out debug resources
+
+			2. Optimize bundle with no minification
+				* /resources/my/lib/Control.js
+
+				=> No action necessary
+
+			3. Debug-bundle with minification already done
+				Workspace:
+					* /resources/my/lib/Control.js 				[ui5:HasDebugVariant]
+					* /resources/my/lib/Control.js.map 			[ui5:HasDebugVariant]
+					* /resources/my/lib/Control-dbg.js 			[ui5:IsDebugVariant]
+
+				Bundler input:
+					* /resources/my/lib/Control-dbg.js
+					* moduleNameMapping: [{"/resources/my/lib/Control-dbg.js": "my/lib/Control.js"}]
+
+				=> Filter out minified-resources (tagged as "HasDebugVariant", incl. source maps) and rename debug-files
+
+			4. Debug-bundle with no minification
+				* /resources/my/lib/Control.js
+
+				=> No action necessary
+
+			5. Bundle with external input (optimize or not), e.g. TS-project
+				Workspace:
+					* /resources/my/lib/Control.ts
+					* /resources/my/lib/Control.js
+					* /resources/my/lib/Control.js.map
+
+				Bundler input:
+					* /resources/my/lib/Control.js
+					* /resources/my/lib/Control.js.map
+		*/
+
+		// Omit -dbg files for optimize bundles and vice versa
+		const filterTag = optimize ?
+			taskUtil.STANDARD_TAGS.IsDebugVariant : taskUtil.STANDARD_TAGS.HasDebugVariant;
+		combo = combo.filter(function(resource) {
+			return !taskUtil.getTag(resource, filterTag);
+		});
+	}
+
+	return combo.byGlob("/resources/**/*.{js,json,xml,html,properties,library,js.map}").then((resources) => {
+		const moduleNameMapping = {};
+		if (!optimize && taskUtil) {
+			// For "unoptimized" bundles, the non-debug files have already been filtered out above.
+			// Now we need to create a mapping from the debug-variant resource path to the respective module name,
+			// which is basically the non-debug resource path, minus the "/resources/"" prefix.
+			// This mapping overwrites internal logic of the LocatorResourcePool which would otherwise determine
+			// the module name from the resource path, which would contain "-dbg" in this case. That would be
+			// incorrect since debug-variants should still keep the original module name.
+			for (let i = resources.length - 1; i >= 0; i--) {
+				const resourcePath = resources[i].getPath();
+				if (taskUtil.getTag(resourcePath, taskUtil.STANDARD_TAGS.IsDebugVariant)) {
+					const nonDbgPath = ModuleName.getNonDebugName(resourcePath);
+					if (!nonDbgPath) {
+						throw new Error(`Failed to resolve non-debug name for ${resourcePath}`);
+					}
+					moduleNameMapping[resourcePath] = nonDbgPath.slice("/resources/".length);
+				}
+			}
+		}
 		return moduleBundler({
 			options: {
 				bundleDefinition,
-				bundleOptions
+				bundleOptions,
+				moduleNameMapping
 			},
 			resources
 		}).then((bundles) => {
-			return Promise.all(bundles.map((bundle) => {
+			return Promise.all(bundles.map(({bundle, sourceMap}) => {
 				if (taskUtil) {
 					taskUtil.setTag(bundle, taskUtil.STANDARD_TAGS.IsBundle);
+					if (sourceMap) {
+						// Clear tag that might have been set by the minify task, in cases where
+						// the bundle name is identical to a source file
+						taskUtil.clearTag(sourceMap, taskUtil.STANDARD_TAGS.OmitFromBuildResult);
+					}
+				}
+				const writes = [workspace.write(bundle)];
+				if (sourceMap) {
+					writes.push(workspace.write(sourceMap));
 				}
-				return workspace.write(bundle);
+				return Promise.all(writes);
 			}));
 		});
 	});

package/lib/tasks/bundlers/generateComponentPreload.js

@@ -28,13 +28,20 @@ const {negateFilters} = require("../../lbt/resources/ResourceFilterList");
 module.exports = function({
 	workspace, dependencies, taskUtil, options: {projectName, paths, namespaces, excludes = []}
 }) {
-	const combo = new ReaderCollectionPrioritized({
+	let combo = new ReaderCollectionPrioritized({
 		name: `generateComponentPreload - prioritize workspace over dependencies: ${projectName}`,
 		readers: [workspace, dependencies]
 	});
 
+	if (taskUtil) {
+		combo = combo.filter(function(resource) {
+			// Remove any debug variants
+			return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant);
+		});
+	}
+
 	// TODO 3.0: Limit to workspace resources?
-	return combo.byGlob("/resources/**/*.{js,json,xml,html,properties,library}")
+	return combo.byGlob("/resources/**/*.{js,json,xml,html,properties,library,js.map}")
 		.then(async (resources) => {
 			let allNamespaces = [];
 			if (paths) {
@@ -141,12 +148,19 @@ module.exports = function({
 				});
 			}));
 		})
-		.then((processedResources) => {
-			return Promise.all(processedResources.map((resource) => {
+		.then((results) => {
+			const bundles = Array.prototype.concat.apply([], results);
+			return Promise.all(bundles.map(({bundle, sourceMap}) => {
 				if (taskUtil) {
-					taskUtil.setTag(resource[0], taskUtil.STANDARD_TAGS.IsBundle);
+					taskUtil.setTag(bundle, taskUtil.STANDARD_TAGS.IsBundle);
+					// Clear tag that might have been set by the minify task, in cases where
+					// the bundle name is identical to a source file
+					taskUtil.clearTag(sourceMap, taskUtil.STANDARD_TAGS.OmitFromBuildResult);
 				}
-				return workspace.write(resource[0]);
+				return Promise.all([
+					workspace.write(bundle),
+					workspace.write(sourceMap)
+				]);
 			}));
 		});
 };