builder/lib/tasks/buildThemes.js

  1. import path from "node:path";
  2. import fsInterface from "@ui5/fs/fsInterface";
  3. import ReaderCollectionPrioritized from "@ui5/fs/ReaderCollectionPrioritized";
  4. import {getLogger} from "@ui5/logger";
  5. const log = getLogger("builder:tasks:buildThemes");
  6. import {fileURLToPath} from "node:url";
  7. import os from "node:os";
  8. import workerpool from "workerpool";
  9. import {deserializeResources, serializeResources, FsMainThreadInterface} from "../processors/themeBuilderWorker.js";
  10. import {setTimeout as setTimeoutPromise} from "node:timers/promises";
  12. let pool;
  14. function getPool(taskUtil) {
  15. 	if (!pool) {
  16. 		const MIN_WORKERS = 2;
  17. 		const MAX_WORKERS = 4;
  18. 		const osCpus = os.cpus().length || 1;
  19. 		const maxWorkers = Math.max(Math.min(osCpus - 1, MAX_WORKERS), MIN_WORKERS);
  21. 		log.verbose(`Creating workerpool with up to ${maxWorkers} workers (available CPU cores: ${osCpus})`);
  22. 		const workerPath = fileURLToPath(new URL("../processors/themeBuilderWorker.js", import.meta.url));
  23. 		pool = workerpool.pool(workerPath, {
  24. 			workerType: "thread",
  25. 			maxWorkers
  26. 		});
  27. 		taskUtil.registerCleanupTask((force) => {
  28. 			const attemptPoolTermination = async () => {
  29. 				log.verbose(`Attempt to terminate the workerpool...`);
  31. 				if (!pool) {
  32. 					return;
  33. 				}
  35. 				// There are many stats that could be used, but these ones seem the most
  36. 				// convenient. When all the (available) workers are idle, then it's safe to terminate.
  37. 				let {idleWorkers, totalWorkers} = pool.stats();
  38. 				while (idleWorkers !== totalWorkers && !force) {
  39. 					await setTimeoutPromise(100); // Wait a bit workers to finish and try again
  41. 					if (!pool) { // pool might have been terminated in the meantime
  42. 						return;
  43. 					}
  44. 					({idleWorkers, totalWorkers} = pool.stats());
  45. 				}
  47. 				const poolToBeTerminated = pool;
  48. 				pool = null;
  49. 				return poolToBeTerminated.terminate(force);
  50. 			};
  52. 			return attemptPoolTermination();
  53. 		});
  54. 	}
  55. 	return pool;
  56. }
  58. async function buildThemeInWorker(taskUtil, options, transferList) {
  59. 	const toTransfer = transferList ? {transfer: transferList} : undefined;
  61. 	return getPool(taskUtil).exec("execThemeBuild", [options], toTransfer);
  62. }
  65. /**
  66.  * @public
  67.  * @module @ui5/builder/tasks/buildThemes
  68.  */
  69. /**
  70.  * Task to build a library theme.
  71.  *
  72.  * @public
  73.  * @function default
  74.  * @static
  75.  *
  76.  * @param {object} parameters Parameters
  77.  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
  78.  * @param {@ui5/fs/AbstractReader} parameters.dependencies Reader or Collection to read dependency files
  79.  * @param {@ui5/builder/tasks/TaskUtil|object} [parameters.taskUtil] TaskUtil instance.
  80.  *    Required to run buildThemes in parallel execution mode.
  81.  * @param {object} parameters.options Options
  82.  * @param {string} parameters.options.projectName Project name
  83.  * @param {string} parameters.options.inputPattern Search pattern for *.less files to be built
  84.  * @param {string} [parameters.options.librariesPattern] Search pattern for .library files
  85.  * @param {string} [parameters.options.themesPattern] Search pattern for sap.ui.core theme folders
  86.  * @param {boolean} [parameters.options.compress=true]
  87.  * @param {boolean} [parameters.options.cssVariables=false]
  88.  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  89.  */
  90. export default async function({
  91. 	workspace, dependencies, taskUtil,
  92. 	options: {
  93. 		projectName, inputPattern, librariesPattern, themesPattern, compress,
  94. 		cssVariables
  95. 	}
  96. }) {
  97. 	const combo = new ReaderCollectionPrioritized({
  98. 		name: `theme - prioritize workspace over dependencies: ${projectName}`,
  99. 		readers: [workspace, dependencies]
  100. 	});
  102. 	compress = compress === undefined ? true : compress;
  104. 	const pThemeResources = workspace.byGlob(inputPattern);
  105. 	let pAvailableLibraries;
  106. 	let pAvailableThemes;
  107. 	if (librariesPattern) {
  108. 		// If a librariesPattern is given
  109. 		//	we will use it to reduce the set of libraries a theme will be built for
  110. 		pAvailableLibraries = combo.byGlob(librariesPattern);
  111. 	}
  112. 	if (themesPattern) {
  113. 		// If a themesPattern is given
  114. 		//	we will use it to reduce the set of themes that will be built
  115. 		pAvailableThemes = combo.byGlob(themesPattern, {nodir: false});
  116. 	}
  118. 	/* Don't try to build themes for libraries that are not available
  119. 	(maybe replace this with something more aware of which dependencies are optional and therefore
  120. 		legitimately missing and which not (fault case))
  121. 		*/
  122. 	let availableLibraries;
  123. 	if (pAvailableLibraries) {
  124. 		availableLibraries = [];
  125. 		(await pAvailableLibraries).forEach((resource) => {
  126. 			const library = path.dirname(resource.getPath());
  127. 			if (!availableLibraries.includes(library)) {
  128. 				availableLibraries.push(library);
  129. 			}
  130. 		});
  131. 	}
  132. 	let availableThemes;
  133. 	if (pAvailableThemes) {
  134. 		availableThemes = (await pAvailableThemes)
  135. 			.filter((resource) => resource.getStatInfo().isDirectory())
  136. 			.map((resource) => {
  137. 				return path.basename(resource.getPath());
  138. 			});
  139. 	}
  141. 	let themeResources = await pThemeResources;
  143. 	const isAvailable = function(resource) {
  144. 		let libraryAvailable = false;
  145. 		let themeAvailable = false;
  146. 		const resourcePath = resource.getPath();
  147. 		const themeName = path.basename(path.dirname(resourcePath));
  149. 		if (!availableLibraries || availableLibraries.length === 0) {
  150. 			libraryAvailable = true; // If no libraries are found, build themes for all libraries
  151. 		} else {
  152. 			for (let i = availableLibraries.length - 1; i >= 0; i--) {
  153. 				if (resourcePath.startsWith(availableLibraries[i])) {
  154. 					libraryAvailable = true;
  155. 				}
  156. 			}
  157. 		}
  159. 		if (!availableThemes || availableThemes.length === 0) {
  160. 			themeAvailable = true; // If no themes are found, build all themes
  161. 		} else {
  162. 			themeAvailable = availableThemes.includes(themeName);
  163. 		}
  165. 		if (log.isLevelEnabled("verbose")) {
  166. 			if (!libraryAvailable) {
  167. 				log.silly(`Skipping ${resourcePath}: Library is not available`);
  168. 			}
  169. 			if (!themeAvailable) {
  170. 				log.verbose(`Skipping ${resourcePath}: sap.ui.core theme '${themeName}' is not available. ` +
  171. 				"If you experience missing themes, check whether you have added the corresponding theme " +
  172. 				"library to your projects dependencies and make sure that your custom themes contain " +
  173. 				"resources for the sap.ui.core namespace.");
  174. 			}
  175. 		}
  177. 		// Only build if library and theme are available
  178. 		return libraryAvailable && themeAvailable;
  179. 	};
  181. 	if (availableLibraries || availableThemes) {
  182. 		if (log.isLevelEnabled("verbose")) {
  183. 			log.verbose("Filtering themes to be built:");
  184. 			if (availableLibraries) {
  185. 				log.verbose(`Available libraries: ${availableLibraries.join(", ")}`);
  186. 			}
  187. 			if (availableThemes) {
  188. 				log.verbose(`Available sap.ui.core themes: ${availableThemes.join(", ")}`);
  189. 			}
  190. 		}
  191. 		themeResources = themeResources.filter(isAvailable);
  192. 	}
  194. 	let processedResources;
  195. 	const useWorkers = !!taskUtil;
  196. 	if (useWorkers) {
  197. 		const threadMessageHandler = new FsMainThreadInterface(fsInterface(combo));
  199. 		processedResources = await Promise.all(themeResources.map(async (themeRes) => {
  200. 			const {port1, port2} = new MessageChannel();
  201. 			threadMessageHandler.startCommunication(port1);
  203. 			const result = await buildThemeInWorker(taskUtil, {
  204. 				fsInterfacePort: port2,
  205. 				themeResources: await serializeResources([themeRes]),
  206. 				options: {
  207. 					compress,
  208. 					cssVariables: !!cssVariables,
  209. 				},
  210. 			}, [port2]);
  212. 			threadMessageHandler.endCommunication(port1);
  214. 			return result;
  215. 		}))
  216. 			.then((resources) => Array.prototype.concat.apply([], resources))
  217. 			.then(deserializeResources);
  219. 		threadMessageHandler.cleanup();
  220. 	} else {
  221. 		// Do not use workerpool
  222. 		const themeBuilder = (await import("../processors/themeBuilder.js")).default;
  224. 		processedResources = await themeBuilder({
  225. 			resources: themeResources,
  226. 			fs: fsInterface(combo),
  227. 			options: {
  228. 				compress,
  229. 				cssVariables: !!cssVariables,
  230. 			}
  231. 		});
  232. 	}
  234. 	await Promise.all(processedResources.map((resource) => {
  235. 		return workspace.write(resource);
  236. 	}));
  237. }