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 {applyDefaultsToBundleDefinition} from "./utils/applyDefaultsToBundleDefinition.js";
  5. import {negateFilters} from "../../lbt/resources/ResourceFilterList.js";
  6. import createModuleNameMapping from "./utils/createModuleNameMapping.js";
  8. function getDefaultLibraryPreloadFilters(namespace, excludes) {
  9. 	const filters = [
  10. 		`${namespace}/`,
  11. 		`${namespace}/**/manifest.json`,
  12. 		`!${namespace}/**/*-preload.js`, // exclude all bundles
  13. 		`!${namespace}/designtime/`,
  14. 		`!${namespace}/**/*.designtime.js`,
  15. 		`!${namespace}/**/*.support.js`
  16. 	];
  18. 	if (Array.isArray(excludes)) {
  19. 		const allFilterExcludes = negateFilters(excludes);
  20. 		// Add configured excludes at the end of filter list
  21. 		allFilterExcludes.forEach((filterExclude) => {
  22. 			// Allow all excludes (!) and limit re-includes (+) to the library namespace
  23. 			if (filterExclude.startsWith("!") || filterExclude.startsWith(`+${namespace}/`)) {
  24. 				filters.push(filterExclude);
  25. 			} else {
  26. 				log.warn(`Configured preload exclude contains invalid re-include: !${filterExclude.substr(1)}. ` +
  27. 				`Re-includes must start with the library's namespace ${namespace}`);
  28. 			}
  29. 		});
  30. 	}
  32. 	return filters;
  33. }
  35. function getBundleDefinition(namespace, excludes) {
  36. 	// Note: This configuration is only used when no bundle definition in ui5.yaml exists (see "skipBundles" parameter)
  38. 	// TODO: Remove this hardcoded bundle definition once support for relevant versions has ended.
  39. 	// sap.ui.core ui5.yaml contains a configuration since UI5 1.103.0 (specVersion 2.4)
  40. 	// so this is still required to build UI5 versions <= 1.102.0 (such as 1.84 and 1.96)
  41. 	if (namespace === "sap/ui/core") {
  42. 		return {
  43. 			name: `${namespace}/library-preload.js`,
  44. 			sections: [
  45. 				{
  46. 					// exclude the content of sap-ui-core by declaring it as 'provided'
  47. 					mode: "provided",
  48. 					filters: [
  49. 						"ui5loader-autoconfig.js",
  50. 						"sap/ui/core/Core.js"
  51. 					],
  52. 					resolve: true
  53. 				},
  54. 				{
  55. 					mode: "preload",
  56. 					filters: [
  57. 						// Note: Don't pass configured preload excludes for sap.ui.core
  58. 						// as they are already hardcoded below.
  59. 						...getDefaultLibraryPreloadFilters(namespace),
  61. 						`!${namespace}/cldr/`,
  62. 						"*.js",
  63. 						"sap/base/",
  64. 						"sap/ui/base/",
  65. 						"sap/ui/dom/",
  66. 						"sap/ui/events/",
  67. 						"sap/ui/model/",
  68. 						"sap/ui/security/",
  69. 						"sap/ui/util/",
  70. 						"sap/ui/Global.js",
  72. 						// include only thirdparty that is very likely to be used
  73. 						"sap/ui/thirdparty/crossroads.js",
  74. 						"sap/ui/thirdparty/caja-html-sanitizer.js",
  75. 						"sap/ui/thirdparty/hasher.js",
  76. 						"sap/ui/thirdparty/signals.js",
  77. 						"sap/ui/thirdparty/jquery-mobile-custom.js",
  78. 						"sap/ui/thirdparty/jqueryui/jquery-ui-core.js",
  79. 						"sap/ui/thirdparty/jqueryui/jquery-ui-position.js",
  81. 						// other excludes (not required for productive scenarios)
  82. 						"!sap-ui-*.js",
  83. 						"!sap/ui/core/support/",
  84. 						"!sap/ui/core/plugin/DeclarativeSupport.js",
  85. 						"!sap/ui/core/plugin/LessSupport.js"
  87. 					],
  88. 					resolve: false,
  89. 					resolveConditional: false,
  90. 					renderer: true
  91. 				}
  92. 			]
  93. 		};
  94. 	}
  95. 	return {
  96. 		name: `${namespace}/library-preload.js`,
  97. 		sections: [
  98. 			{
  99. 				mode: "preload",
  100. 				filters: getDefaultLibraryPreloadFilters(namespace, excludes),
  101. 				resolve: false,
  102. 				resolveConditional: false,
  103. 				renderer: true
  104. 			}
  105. 		]
  106. 	};
  107. }
  109. function getDesigntimeBundleDefinition(namespace) {
  110. 	return {
  111. 		name: `${namespace}/designtime/library-preload.designtime.js`,
  112. 		sections: [
  113. 			{
  114. 				mode: "preload",
  115. 				filters: [
  116. 					`${namespace}/**/*.designtime.js`,
  117. 					`${namespace}/designtime/`,
  118. 					`!${namespace}/**/*-preload.designtime.js`,
  119. 					`!${namespace}/designtime/**/*.properties`,
  120. 					`!${namespace}/designtime/**/*.svg`,
  121. 					`!${namespace}/designtime/**/*.xml`
  122. 				],
  123. 				resolve: false,
  124. 				resolveConditional: false,
  125. 				renderer: false
  126. 			}
  127. 		]
  128. 	};
  129. }
  131. function getSupportFilesBundleDefinition(namespace) {
  132. 	return {
  133. 		name: `${namespace}/library-preload.support.js`,
  134. 		sections: [
  135. 			{
  136. 				mode: "preload",
  137. 				filters: [
  138. 					`${namespace}/**/*.support.js`,
  139. 					`!${namespace}/**/*-preload.support.js`
  140. 				],
  141. 				resolve: false,
  142. 				resolveConditional: false,
  143. 				renderer: false
  144. 			}
  145. 		]
  146. 	};
  147. }
  149. function getModuleBundlerOptions(config) {
  150. 	const moduleBundlerOptions = {};
  152. 	// required in sap-ui-core-nojQuery.js and sap-ui-core-nojQuery-dbg.js
  153. 	const providedSection = {
  154. 		mode: "provided",
  155. 		filters: [
  156. 			"jquery-ui-core.js",
  157. 			"jquery-ui-datepicker.js",
  158. 			"jquery-ui-position.js",
  159. 			"sap/ui/thirdparty/jquery.js",
  160. 			"sap/ui/thirdparty/jquery/*",
  161. 			"sap/ui/thirdparty/jqueryui/*"
  162. 		]
  163. 	};
  165. 	moduleBundlerOptions.bundleOptions = {
  166. 		optimize: config.preload,
  167. 		decorateBootstrapModule: config.preload,
  168. 		addTryCatchRestartWrapper: 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. 	}
  259. 	const coreVersion = taskUtil?.getProject("sap.ui.core")?.getVersion();
  260. 	const allowStringBundling = taskUtil?.getProject().getSpecVersion().lt("4.0");
  261. 	const execModuleBundlerIfNeeded = ({options, resources}) => {
  262. 		if (skipBundles.includes(options.bundleDefinition.name)) {
  263. 			log.verbose(`Skipping generation of bundle ${options.bundleDefinition.name}`);
  264. 			return null;
  265. 		}
  266. 		if (coreVersion) {
  267. 			options.targetUi5CoreVersion = coreVersion;
  268. 		}
  269. 		options.bundleDefinition = applyDefaultsToBundleDefinition(options.bundleDefinition, taskUtil);
  270. 		options.allowStringBundling = allowStringBundling;
  271. 		return moduleBundler({options, resources});
  272. 	};
  274. 	return nonDbgWorkspace.byGlob("/**/*.{js,json,xml,html,properties,library,js.map}").then(async (resources) => {
  275. 		// Find all libraries and create a library-preload.js bundle
  277. 		let p = Promise.resolve();
  279. 		// Create core bundles for older versions (<1.97.0) which don't define bundle configuration in the ui5.yaml
  280. 		// See: https://github.com/SAP/openui5/commit/ff127fd2d009162ea43ad312dec99d759ebc23a0
  281. 		if (projectName === "sap.ui.core") {
  282. 			// Instead of checking the sap.ui.core library version, the specVersion is checked against all versions
  283. 			// that have been defined for sap.ui.core before the bundle configuration has been introduced.
  284. 			// This is mainly to have an easier check without version parsing or using semver.
  285. 			// If no project/specVersion is available, the bundles should also be created to not break potential
  286. 			// existing use cases without a properly formed/formatted project tree.
  287. 			if (!taskUtil || taskUtil.getProject().getSpecVersion().lte("2.0")) {
  288. 				const isEvo = resources.find((resource) => {
  289. 					return resource.getPath() === "/resources/ui5loader.js";
  290. 				});
  292. 				let unoptimizedModuleNameMapping;
  293. 				let unoptimizedResources = resources;
  294. 				if (taskUtil) {
  295. 					const unoptimizedWorkspace = taskUtil.resourceFactory.createFilterReader({
  296. 						reader: workspace,
  297. 						callback: function(resource) {
  298. 							// Remove any non-debug variants
  299. 							return !taskUtil.getTag(resource, taskUtil.STANDARD_TAGS.HasDebugVariant);
  300. 						}
  301. 					});
  302. 					unoptimizedResources =
  303. 						await unoptimizedWorkspace.byGlob("/**/*.{js,json,xml,html,properties,library,js.map}");
  305. 					unoptimizedModuleNameMapping = createModuleNameMapping({
  306. 						resources: unoptimizedResources,
  307. 						taskUtil
  308. 					});
  309. 				}
  311. 				let filters;
  312. 				if (isEvo) {
  313. 					filters = ["ui5loader-autoconfig.js"];
  314. 				} else {
  315. 					filters = ["jquery.sap.global.js"];
  316. 				}
  317. 				p = Promise.all([
  318. 					execModuleBundlerIfNeeded({
  319. 						options: getModuleBundlerOptions({name: "sap-ui-core.js", filters, preload: true}),
  320. 						resources
  321. 					}),
  322. 					execModuleBundlerIfNeeded({
  323. 						options: getModuleBundlerOptions({
  324. 							name: "sap-ui-core-dbg.js", filters, preload: false,
  325. 							moduleNameMapping: unoptimizedModuleNameMapping
  326. 						}),
  327. 						resources: unoptimizedResources
  328. 					}),
  329. 					execModuleBundlerIfNeeded({
  330. 						options: getModuleBundlerOptions({
  331. 							name: "sap-ui-core-nojQuery.js", filters, preload: true, provided: true
  332. 						}),
  333. 						resources
  334. 					}),
  335. 					execModuleBundlerIfNeeded({
  336. 						options: getModuleBundlerOptions({
  337. 							name: "sap-ui-core-nojQuery-dbg.js", filters, preload: false, provided: true,
  338. 							moduleNameMapping: unoptimizedModuleNameMapping
  339. 						}),
  340. 						resources: unoptimizedResources
  341. 					}),
  342. 				]).then((results) => {
  343. 					const bundles = Array.prototype.concat.apply([], results).filter(Boolean);
  344. 					return Promise.all(bundles.map(({bundle, sourceMap}) => {
  345. 						if (taskUtil) {
  346. 							taskUtil.setTag(bundle, taskUtil.STANDARD_TAGS.IsBundle);
  347. 							if (sourceMap) {
  348. 								// Clear tag that might have been set by the minify task, in cases where
  349. 								// the bundle name is identical to a source file
  350. 								taskUtil.clearTag(sourceMap, taskUtil.STANDARD_TAGS.OmitFromBuildResult);
  351. 							}
  352. 						}
  353. 						const writes = [workspace.write(bundle)];
  354. 						if (sourceMap) {
  355. 							writes.push(workspace.write(sourceMap));
  356. 						}
  357. 						return Promise.all(writes);
  358. 					}));
  359. 				});
  360. 			}
  361. 		}
  363. 		return p.then(() => {
  364. 			return workspace.byGlob("/resources/**/.library").then((libraryIndicatorResources) => {
  365. 				if (libraryIndicatorResources.length > 0) {
  366. 					return libraryIndicatorResources;
  367. 				} else {
  368. 					// Fallback to "library.js" as library indicator
  369. 					log.verbose(
  370. 						`Could not find a ".library" file for project ${projectName}, ` +
  371. 						`falling back to "library.js".`);
  372. 					return workspace.byGlob("/resources/**/library.js");
  373. 				}
  374. 			}).then((libraryIndicatorResources) => {
  375. 				if (libraryIndicatorResources.length < 1) {
  376. 					// No library found - nothing to do
  377. 					log.verbose(
  378. 						`Could not find a ".library" or "library.js" file for project ${projectName}. ` +
  379. 						`Skipping library preload bundling.`);
  380. 					return;
  381. 				}
  383. 				return Promise.all(libraryIndicatorResources.map(async (libraryIndicatorResource) => {
  384. 					// Determine library namespace from library indicator file path
  385. 					// ending with either ".library" or "library.js" (see fallback logic above)
  386. 					// e.g. /resources/sap/foo/.library => sap/foo
  387. 					//      /resources/sap/bar/library.js => sap/bar
  388. 					const libraryNamespacePattern = /^\/resources\/(.*)\/(?:\.library|library\.js)$/;
  389. 					const libraryIndicatorPath = libraryIndicatorResource.getPath();
  390. 					const libraryNamespaceMatch = libraryIndicatorPath.match(libraryNamespacePattern);
  391. 					if (libraryNamespaceMatch && libraryNamespaceMatch[1]) {
  392. 						const libraryNamespace = libraryNamespaceMatch[1];
  393. 						const results = await Promise.all([
  394. 							execModuleBundlerIfNeeded({
  395. 								options: {
  396. 									bundleDefinition: getBundleDefinition(libraryNamespace, excludes),
  397. 									bundleOptions: {
  398. 										optimize: true,
  399. 										ignoreMissingModules: true
  400. 									}
  401. 								},
  402. 								resources
  403. 							}),
  404. 							execModuleBundlerIfNeeded({
  405. 								options: {
  406. 									bundleDefinition: getDesigntimeBundleDefinition(libraryNamespace),
  407. 									bundleOptions: {
  408. 										optimize: true,
  409. 										ignoreMissingModules: true,
  410. 										skipIfEmpty: true
  411. 									}
  412. 								},
  413. 								resources
  414. 							}),
  415. 							execModuleBundlerIfNeeded({
  416. 								options: {
  417. 									bundleDefinition: getSupportFilesBundleDefinition(libraryNamespace),
  418. 									bundleOptions: {
  419. 										optimize: false,
  420. 										ignoreMissingModules: true,
  421. 										skipIfEmpty: true
  422. 									}
  423. 									// Note: Although the bundle uses optimize=false, there is
  424. 									// no moduleNameMapping needed, as support files are excluded from minification.
  425. 								},
  426. 								resources
  427. 							})
  428. 						]);
  429. 						const bundles = Array.prototype.concat.apply([], results).filter(Boolean);
  430. 						return Promise.all(bundles.map(({bundle, sourceMap} = {}) => {
  431. 							if (bundle) {
  432. 								if (taskUtil) {
  433. 									taskUtil.setTag(bundle, taskUtil.STANDARD_TAGS.IsBundle);
  434. 									if (sourceMap) {
  435. 										// Clear tag that might have been set by the minify task, in cases where
  436. 										// the bundle name is identical to a source file
  437. 										taskUtil.clearTag(sourceMap,
  438. 											taskUtil.STANDARD_TAGS.OmitFromBuildResult);
  439. 									}
  440. 								}
  441. 								const writes = [workspace.write(bundle)];
  442. 								if (sourceMap) {
  443. 									writes.push(workspace.write(sourceMap));
  444. 								}
  445. 								return Promise.all(writes);
  446. 							}
  447. 						}));
  448. 					} else {
  449. 						log.verbose(
  450. 							`Could not determine library namespace from file "${libraryIndicatorPath}" ` +
  451. 							`for project ${projectName}. Skipping library preload bundling.`);
  452. 						return Promise.resolve();
  453. 					}
  454. 				}));
  455. 			});
  456. 		});
  457. 	});
  458. }