builder/lib/tasks/bundlers/generateLibraryPreload.js

  1. import {getLogger} from "@ui5/logger";
  2. const log = getLogger("builder:tasks:bundlers:generateLibraryPreload");
  3. import moduleBundler from "../../processors/bundlers/moduleBundler.js";
  4. import {negateFilters} from "../../lbt/resources/ResourceFilterList.js";
  5. import createModuleNameMapping from "./utils/createModuleNameMapping.js";
  7. function getDefaultLibraryPreloadFilters(namespace, excludes) {
  8. 	const filters = [
  9. 		`${namespace}/`,
  10. 		`${namespace}/**/manifest.json`,
  11. 		`!${namespace}/**/*-preload.js`, // exclude all bundles
  12. 		`!${namespace}/designtime/`,
  13. 		`!${namespace}/**/*.designtime.js`,
  14. 		`!${namespace}/**/*.support.js`
  15. 	];
  17. 	if (Array.isArray(excludes)) {
  18. 		const allFilterExcludes = negateFilters(excludes);
  19. 		// Add configured excludes at the end of filter list
  20. 		allFilterExcludes.forEach((filterExclude) => {
  21. 			// Allow all excludes (!) and limit re-includes (+) to the library namespace
  22. 			if (filterExclude.startsWith("!") || filterExclude.startsWith(`+${namespace}/`)) {
  23. 				filters.push(filterExclude);
  24. 			} else {
  25. 				log.warn(`Configured preload exclude contains invalid re-include: !${filterExclude.substr(1)}. ` +
  26. 				`Re-includes must start with the library's namespace ${namespace}`);
  27. 			}
  28. 		});
  29. 	}
  31. 	return filters;
  32. }
  34. function getBundleDefinition(namespace, excludes) {
  35. 	// Note: This configuration is only used when no bundle definition in ui5.yaml exists (see "skipBundles" parameter)
  37. 	// TODO: Remove this hardcoded bundle definition.
  38. 	// sap.ui.core ui5.yaml contains a configuration since UI5 1.103.0 (specVersion 2.4)
  39. 	// so this is still required to build UI5 versions <= 1.102.0.
  40. 	if (namespace === "sap/ui/core") {
  41. 		return {
  42. 			name: `${namespace}/library-preload.js`,
  43. 			sections: [
  44. 				{
  45. 					// exclude the content of sap-ui-core by declaring it as 'provided'
  46. 					mode: "provided",
  47. 					filters: [
  48. 						"ui5loader-autoconfig.js",
  49. 						"sap/ui/core/Core.js"
  50. 					],
  51. 					resolve: true
  52. 				},
  53. 				{
  54. 					mode: "preload",
  55. 					filters: [
  56. 						// Note: Don't pass configured preload excludes for sap.ui.core
  57. 						// as they are already hardcoded below.
  58. 						...getDefaultLibraryPreloadFilters(namespace),
  60. 						`!${namespace}/cldr/`,
  61. 						"*.js",
  62. 						"sap/base/",
  63. 						"sap/ui/base/",
  64. 						"sap/ui/dom/",
  65. 						"sap/ui/events/",
  66. 						"sap/ui/model/",
  67. 						"sap/ui/security/",
  68. 						"sap/ui/util/",
  69. 						"sap/ui/Global.js",
  71. 						// include only thirdparty that is very likely to be used
  72. 						"sap/ui/thirdparty/crossroads.js",
  73. 						"sap/ui/thirdparty/caja-html-sanitizer.js",
  74. 						"sap/ui/thirdparty/hasher.js",
  75. 						"sap/ui/thirdparty/signals.js",
  76. 						"sap/ui/thirdparty/jquery-mobile-custom.js",
  77. 						"sap/ui/thirdparty/jqueryui/jquery-ui-core.js",
  78. 						"sap/ui/thirdparty/jqueryui/jquery-ui-position.js",
  80. 						// other excludes (not required for productive scenarios)
  81. 						"!sap-ui-*.js",
  82. 						"!sap/ui/core/support/",
  83. 						"!sap/ui/core/plugin/DeclarativeSupport.js",
  84. 						"!sap/ui/core/plugin/LessSupport.js"
  86. 					],
  87. 					resolve: false,
  88. 					resolveConditional: false,
  89. 					renderer: true
  90. 				}
  91. 			]
  92. 		};
  93. 	}
  94. 	return {
  95. 		name: `${namespace}/library-preload.js`,
  96. 		sections: [
  97. 			{
  98. 				mode: "preload",
  99. 				filters: getDefaultLibraryPreloadFilters(namespace, excludes),
  100. 				resolve: false,
  101. 				resolveConditional: false,
  102. 				renderer: true
  103. 			}
  104. 		]
  105. 	};
  106. }
  108. function getDesigntimeBundleDefinition(namespace) {
  109. 	return {
  110. 		name: `${namespace}/designtime/library-preload.designtime.js`,
  111. 		sections: [
  112. 			{
  113. 				mode: "preload",
  114. 				filters: [
  115. 					`${namespace}/**/*.designtime.js`,
  116. 					`${namespace}/designtime/`,
  117. 					`!${namespace}/**/*-preload.designtime.js`,
  118. 					`!${namespace}/designtime/**/*.properties`,
  119. 					`!${namespace}/designtime/**/*.svg`,
  120. 					`!${namespace}/designtime/**/*.xml`
  121. 				],
  122. 				resolve: false,
  123. 				resolveConditional: false,
  124. 				renderer: false
  125. 			}
  126. 		]
  127. 	};
  128. }
  130. function getSupportFilesBundleDefinition(namespace) {
  131. 	return {
  132. 		name: `${namespace}/library-preload.support.js`,
  133. 		sections: [
  134. 			{
  135. 				mode: "preload",
  136. 				filters: [
  137. 					`${namespace}/**/*.support.js`,
  138. 					`!${namespace}/**/*-preload.support.js`
  139. 				],
  140. 				resolve: false,
  141. 				resolveConditional: false,
  142. 				renderer: false
  143. 			}
  144. 		]
  145. 	};
  146. }
  148. function getModuleBundlerOptions(config) {
  149. 	const moduleBundlerOptions = {};
  151. 	// required in sap-ui-core-nojQuery.js and sap-ui-core-nojQuery-dbg.js
  152. 	const providedSection = {
  153. 		mode: "provided",
  154. 		filters: [
  155. 			"jquery-ui-core.js",
  156. 			"jquery-ui-datepicker.js",
  157. 			"jquery-ui-position.js",
  158. 			"sap/ui/thirdparty/jquery.js",
  159. 			"sap/ui/thirdparty/jquery/*",
  160. 			"sap/ui/thirdparty/jqueryui/*"
  161. 		]
  162. 	};
  164. 	moduleBundlerOptions.bundleOptions = {
  165. 		optimize: config.preload,
  166. 		decorateBootstrapModule: config.preload,
  167. 		addTryCatchRestartWrapper: config.preload,
  168. 		usePredefineCalls: config.preload
  169. 	};
  171. 	moduleBundlerOptions.bundleDefinition = getSapUiCoreBunDef(config.name, config.filters, config.preload);
  173. 	if (config.provided) {
  174. 		moduleBundlerOptions.bundleDefinition.sections.unshift(providedSection);
  175. 	}
  177. 	if (config.moduleNameMapping) {
  178. 		moduleBundlerOptions.moduleNameMapping = config.moduleNameMapping;
  179. 	}
  181. 	return moduleBundlerOptions;
  182. }
  184. function getSapUiCoreBunDef(name, filters, preload) {
  185. 	const bundleDefinition = {
  186. 		name,
  187. 		sections: []
  188. 	};
  190. 	// add raw section
  191. 	bundleDefinition.sections.push({
  192. 		// include all 'raw' modules that are needed for the UI5 loader
  193. 		mode: "raw",
  194. 		filters,
  195. 		resolve: true, // dependencies for raw modules are taken from shims in .library files
  196. 		sort: true, // topological sort on raw modules is mandatory
  197. 		declareModules: false
  198. 	});
  200. 	if (preload) {
  201. 		// add preload section
  202. 		bundleDefinition.sections.push({
  203. 			mode: "preload",
  204. 			filters: [
  205. 				"sap/ui/core/Core.js"
  206. 			],
  207. 			resolve: true
  208. 		});
  209. 	}
  211. 	// add require section
  212. 	bundleDefinition.sections.push({
  213. 		mode: "require",
  214. 		filters: [
  215. 			"sap/ui/core/Core.js"
  216. 		]
  217. 	});
  219. 	return bundleDefinition;
  220. }
  222. /**
  223.  * @public
  224.  * @module @ui5/builder/tasks/bundlers/generateLibraryPreload
  225.  */
  227. /**
  228.  * Task for library bundling.
  229.  *
  230.  * @public
  231.  * @function default
  232.  * @static
  233.  *
  234.  * @param {object} parameters Parameters
  235.  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
  236.  * @param {@ui5/project/build/helpers/TaskUtil} [parameters.taskUtil] TaskUtil
  237.  * @param {object} parameters.options Options
  238.  * @param {string} parameters.options.projectName Project name
  239.  * @param {string[]} [parameters.options.skipBundles] Names of bundles that should not be created
  240.  * @param {string[]} [parameters.options.excludes=[]] List of modules declared as glob patterns (resource name patterns)
  241.  * that should be excluded from the library-preload.js bundle.
  242.  * A pattern ending with a slash '/' will, similarly to the use of a single '*' or double '**' asterisk,
  243.  * denote an arbitrary number of characters or folder names.
  244.  * Re-includes should be marked with a leading exclamation mark '!'. The order of filters is relevant; a later
  245.  * inclusion overrides an earlier exclusion, and vice versa.
  246.  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  247.  */
  248. export default async function({workspace, taskUtil, options: {skipBundles = [], excludes = [], projectName}}) {
  249. 	let nonDbgWorkspace = workspace;
  250. 	if (taskUtil) {
  251. 		nonDbgWorkspace = taskUtil.resourceFactory.createFilterReader({
  252. 			reader: workspace,
  253. 			callback: function(resource) {
  254. 				// Remove any debug variants
  255. 				return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.IsDebugVariant);
  256. 			}
  257. 		});
  258. 	}
  260. 	const execModuleBundlerIfNeeded = ({options, resources}) => {
  261. 		if (skipBundles.includes(options.bundleDefinition.name)) {
  262. 			log.verbose(`Skipping generation of bundle ${options.bundleDefinition.name}`);
  263. 			return null;
  264. 		}
  265. 		return moduleBundler({options, resources});
  266. 	};
  268. 	return nonDbgWorkspace.byGlob("/**/*.{js,json,xml,html,properties,library,js.map}").then(async (resources) => {
  269. 		// Find all libraries and create a library-preload.js bundle
  271. 		let p = Promise.resolve();
  273. 		// Create core bundles for older versions (<1.97.0) which don't define bundle configuration in the ui5.yaml
  274. 		// See: https://github.com/SAP/openui5/commit/ff127fd2d009162ea43ad312dec99d759ebc23a0
  275. 		if (projectName === "sap.ui.core") {
  276. 			// Instead of checking the sap.ui.core library version, the specVersion is checked against all versions
  277. 			// that have been defined for sap.ui.core before the bundle configuration has been introduced.
  278. 			// This is mainly to have an easier check without version parsing or using semver.
  279. 			// If no project/specVersion is available, the bundles should also be created to not break potential
  280. 			// existing use cases without a properly formed/formatted project tree.
  281. 			if (!taskUtil || taskUtil.getProject().getSpecVersion().lte("2.0")) {
  282. 				const isEvo = resources.find((resource) => {
  283. 					return resource.getPath() === "/resources/ui5loader.js";
  284. 				});
  286. 				let unoptimizedModuleNameMapping;
  287. 				let unoptimizedResources = resources;
  288. 				if (taskUtil) {
  289. 					const unoptimizedWorkspace = taskUtil.resourceFactory.createFilterReader({
  290. 						reader: workspace,
  291. 						callback: function(resource) {
  292. 							// Remove any non-debug variants
  293. 							return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.HasDebugVariant);
  294. 						}
  295. 					});
  296. 					unoptimizedResources =
  297. 						await unoptimizedWorkspace.byGlob("/**/*.{js,json,xml,html,properties,library,js.map}");
  299. 					unoptimizedModuleNameMapping = createModuleNameMapping({
  300. 						resources: unoptimizedResources,
  301. 						taskUtil
  302. 					});
  303. 				}
  305. 				let filters;
  306. 				if (isEvo) {
  307. 					filters = ["ui5loader-autoconfig.js"];
  308. 				} else {
  309. 					filters = ["jquery.sap.global.js"];
  310. 				}
  311. 				p = Promise.all([
  312. 					execModuleBundlerIfNeeded({
  313. 						options: getModuleBundlerOptions({name: "sap-ui-core.js", filters, preload: true}),
  314. 						resources
  315. 					}),
  316. 					execModuleBundlerIfNeeded({
  317. 						options: getModuleBundlerOptions({
  318. 							name: "sap-ui-core-dbg.js", filters, preload: false,
  319. 							moduleNameMapping: unoptimizedModuleNameMapping
  320. 						}),
  321. 						resources: unoptimizedResources
  322. 					}),
  323. 					execModuleBundlerIfNeeded({
  324. 						options: getModuleBundlerOptions({
  325. 							name: "sap-ui-core-nojQuery.js", filters, preload: true, provided: true
  326. 						}),
  327. 						resources
  328. 					}),
  329. 					execModuleBundlerIfNeeded({
  330. 						options: getModuleBundlerOptions({
  331. 							name: "sap-ui-core-nojQuery-dbg.js", filters, preload: false, provided: true,
  332. 							moduleNameMapping: unoptimizedModuleNameMapping
  333. 						}),
  334. 						resources: unoptimizedResources
  335. 					}),
  336. 				]).then((results) => {
  337. 					const bundles = Array.prototype.concat.apply([], results).filter(Boolean);
  338. 					return Promise.all(bundles.map(({bundle, sourceMap}) => {
  339. 						if (taskUtil) {
  340. 							taskUtil.setTag(bundle, taskUtil.STANDARD_TAGS.IsBundle);
  341. 							if (sourceMap) {
  342. 								// Clear tag that might have been set by the minify task, in cases where
  343. 								// the bundle name is identical to a source file
  344. 								taskUtil.clearTag(sourceMap, taskUtil.STANDARD_TAGS.OmitFromBuildResult);
  345. 							}
  346. 						}
  347. 						const writes = [workspace.write(bundle)];
  348. 						if (sourceMap) {
  349. 							writes.push(workspace.write(sourceMap));
  350. 						}
  351. 						return Promise.all(writes);
  352. 					}));
  353. 				});
  354. 			}
  355. 		}
  357. 		return p.then(() => {
  358. 			return workspace.byGlob("/resources/**/.library").then((libraryIndicatorResources) => {
  359. 				if (libraryIndicatorResources.length > 0) {
  360. 					return libraryIndicatorResources;
  361. 				} else {
  362. 					// Fallback to "library.js" as library indicator
  363. 					log.verbose(
  364. 						`Could not find a ".library" file for project ${projectName}, ` +
  365. 						`falling back to "library.js".`);
  366. 					return workspace.byGlob("/resources/**/library.js");
  367. 				}
  368. 			}).then((libraryIndicatorResources) => {
  369. 				if (libraryIndicatorResources.length < 1) {
  370. 					// No library found - nothing to do
  371. 					log.verbose(
  372. 						`Could not find a ".library" or "library.js" file for project ${projectName}. ` +
  373. 						`Skipping library preload bundling.`);
  374. 					return;
  375. 				}
  377. 				return Promise.all(libraryIndicatorResources.map(async (libraryIndicatorResource) => {
  378. 					// Determine library namespace from library indicator file path
  379. 					// ending with either ".library" or "library.js" (see fallback logic above)
  380. 					// e.g. /resources/sap/foo/.library => sap/foo
  381. 					//      /resources/sap/bar/library.js => sap/bar
  382. 					const libraryNamespacePattern = /^\/resources\/(.*)\/(?:\.library|library\.js)$/;
  383. 					const libraryIndicatorPath = libraryIndicatorResource.getPath();
  384. 					const libraryNamespaceMatch = libraryIndicatorPath.match(libraryNamespacePattern);
  385. 					if (libraryNamespaceMatch && libraryNamespaceMatch[1]) {
  386. 						const libraryNamespace = libraryNamespaceMatch[1];
  387. 						const results = await Promise.all([
  388. 							execModuleBundlerIfNeeded({
  389. 								options: {
  390. 									bundleDefinition: getBundleDefinition(libraryNamespace, excludes),
  391. 									bundleOptions: {
  392. 										optimize: true,
  393. 										usePredefineCalls: true,
  394. 										ignoreMissingModules: true
  395. 									}
  396. 								},
  397. 								resources
  398. 							}),
  399. 							execModuleBundlerIfNeeded({
  400. 								options: {
  401. 									bundleDefinition: getDesigntimeBundleDefinition(libraryNamespace),
  402. 									bundleOptions: {
  403. 										optimize: true,
  404. 										usePredefineCalls: true,
  405. 										ignoreMissingModules: true,
  406. 										skipIfEmpty: true
  407. 									}
  408. 								},
  409. 								resources
  410. 							}),
  411. 							execModuleBundlerIfNeeded({
  412. 								options: {
  413. 									bundleDefinition: getSupportFilesBundleDefinition(libraryNamespace),
  414. 									bundleOptions: {
  415. 										optimize: false,
  416. 										usePredefineCalls: true,
  417. 										ignoreMissingModules: true,
  418. 										skipIfEmpty: true
  419. 									}
  420. 									// Note: Although the bundle uses optimize=false, there is
  421. 									// no moduleNameMapping needed, as support files are excluded from minification.
  422. 								},
  423. 								resources
  424. 							})
  425. 						]);
  426. 						const bundles = Array.prototype.concat.apply([], results).filter(Boolean);
  427. 						return Promise.all(bundles.map(({bundle, sourceMap} = {}) => {
  428. 							if (bundle) {
  429. 								if (taskUtil) {
  430. 									taskUtil.setTag(bundle, taskUtil.STANDARD_TAGS.IsBundle);
  431. 									if (sourceMap) {
  432. 										// Clear tag that might have been set by the minify task, in cases where
  433. 										// the bundle name is identical to a source file
  434. 										taskUtil.clearTag(sourceMap,
  435. 											taskUtil.STANDARD_TAGS.OmitFromBuildResult);
  436. 									}
  437. 								}
  438. 								const writes = [workspace.write(bundle)];
  439. 								if (sourceMap) {
  440. 									writes.push(workspace.write(sourceMap));
  441. 								}
  442. 								return Promise.all(writes);
  443. 							}
  444. 						}));
  445. 					} else {
  446. 						log.verbose(
  447. 							`Could not determine library namespace from file "${libraryIndicatorPath}" ` +
  448. 							`for project ${projectName}. Skipping library preload bundling.`);
  449. 						return Promise.resolve();
  450. 					}
  451. 				}));
  452. 			});
  453. 		});
  454. 	});
  455. }