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
  40. 					({idleWorkers, totalWorkers} = pool.stats());
  41. 				}
  43. 				const poolToBeTerminated = pool;
  44. 				pool = null;
  45. 				return poolToBeTerminated.terminate(force);
  46. 			};
  48. 			return attemptPoolTermination();
  49. 		});
  50. 	}
  51. 	return pool;
  52. }
  54. async function buildThemeInWorker(taskUtil, options, transferList) {
  55. 	const toTransfer = transferList ? {transfer: transferList} : undefined;
  57. 	return getPool(taskUtil).exec("execThemeBuild", [options], toTransfer);
  58. }
  61. /**
  62.  * @public
  63.  * @module @ui5/builder/tasks/buildThemes
  64.  */
  65. /**
  66.  * Task to build a library theme.
  67.  *
  68.  * @public
  69.  * @function default
  70.  * @static
  71.  *
  72.  * @param {object} parameters Parameters
  73.  * @param {@ui5/fs/DuplexCollection} parameters.workspace DuplexCollection to read and write files
  74.  * @param {@ui5/fs/AbstractReader} parameters.dependencies Reader or Collection to read dependency files
  75.  * @param {@ui5/builder/tasks/TaskUtil|object} [parameters.taskUtil] TaskUtil instance.
  76.  *    Required to run buildThemes in parallel execution mode.
  77.  * @param {object} parameters.options Options
  78.  * @param {string} parameters.options.projectName Project name
  79.  * @param {string} parameters.options.inputPattern Search pattern for *.less files to be built
  80.  * @param {string} [parameters.options.librariesPattern] Search pattern for .library files
  81.  * @param {string} [parameters.options.themesPattern] Search pattern for sap.ui.core theme folders
  82.  * @param {boolean} [parameters.options.compress=true]
  83.  * @param {boolean} [parameters.options.cssVariables=false]
  84.  * @returns {Promise<undefined>} Promise resolving with <code>undefined</code> once data has been written
  85.  */
  86. export default async function({
  87. 	workspace, dependencies, taskUtil,
  88. 	options: {
  89. 		projectName, inputPattern, librariesPattern, themesPattern, compress,
  90. 		cssVariables
  91. 	}
  92. }) {
  93. 	const combo = new ReaderCollectionPrioritized({
  94. 		name: `theme - prioritize workspace over dependencies: ${projectName}`,
  95. 		readers: [workspace, dependencies]
  96. 	});
  98. 	compress = compress === undefined ? true : compress;
  100. 	const pThemeResources = workspace.byGlob(inputPattern);
  101. 	let pAvailableLibraries;
  102. 	let pAvailableThemes;
  103. 	if (librariesPattern) {
  104. 		// If a librariesPattern is given
  105. 		//	we will use it to reduce the set of libraries a theme will be built for
  106. 		pAvailableLibraries = combo.byGlob(librariesPattern);
  107. 	}
  108. 	if (themesPattern) {
  109. 		// If a themesPattern is given
  110. 		//	we will use it to reduce the set of themes that will be built
  111. 		pAvailableThemes = combo.byGlob(themesPattern, {nodir: false});
  112. 	}
  114. 	/* Don't try to build themes for libraries that are not available
  115. 	(maybe replace this with something more aware of which dependencies are optional and therefore
  116. 		legitimately missing and which not (fault case))
  117. 		*/
  118. 	let availableLibraries;
  119. 	if (pAvailableLibraries) {
  120. 		availableLibraries = [];
  121. 		(await pAvailableLibraries).forEach((resource) => {
  122. 			const library = path.dirname(resource.getPath());
  123. 			if (!availableLibraries.includes(library)) {
  124. 				availableLibraries.push(library);
  125. 			}
  126. 		});
  127. 	}
  128. 	let availableThemes;
  129. 	if (pAvailableThemes) {
  130. 		availableThemes = (await pAvailableThemes)
  131. 			.filter((resource) => resource.getStatInfo().isDirectory())
  132. 			.map((resource) => {
  133. 				return path.basename(resource.getPath());
  134. 			});
  135. 	}
  137. 	let themeResources = await pThemeResources;
  139. 	const isAvailable = function(resource) {
  140. 		let libraryAvailable = false;
  141. 		let themeAvailable = false;
  142. 		const resourcePath = resource.getPath();
  143. 		const themeName = path.basename(path.dirname(resourcePath));
  145. 		if (!availableLibraries || availableLibraries.length === 0) {
  146. 			libraryAvailable = true; // If no libraries are found, build themes for all libraries
  147. 		} else {
  148. 			for (let i = availableLibraries.length - 1; i >= 0; i--) {
  149. 				if (resourcePath.startsWith(availableLibraries[i])) {
  150. 					libraryAvailable = true;
  151. 				}
  152. 			}
  153. 		}
  155. 		if (!availableThemes || availableThemes.length === 0) {
  156. 			themeAvailable = true; // If no themes are found, build all themes
  157. 		} else {
  158. 			themeAvailable = availableThemes.includes(themeName);
  159. 		}
  161. 		if (log.isLevelEnabled("verbose")) {
  162. 			if (!libraryAvailable) {
  163. 				log.silly(`Skipping ${resourcePath}: Library is not available`);
  164. 			}
  165. 			if (!themeAvailable) {
  166. 				log.verbose(`Skipping ${resourcePath}: sap.ui.core theme '${themeName}' is not available. ` +
  167. 				"If you experience missing themes, check whether you have added the corresponding theme " +
  168. 				"library to your projects dependencies and make sure that your custom themes contain " +
  169. 				"resources for the sap.ui.core namespace.");
  170. 			}
  171. 		}
  173. 		// Only build if library and theme are available
  174. 		return libraryAvailable && themeAvailable;
  175. 	};
  177. 	if (availableLibraries || availableThemes) {
  178. 		if (log.isLevelEnabled("verbose")) {
  179. 			log.verbose("Filtering themes to be built:");
  180. 			if (availableLibraries) {
  181. 				log.verbose(`Available libraries: ${availableLibraries.join(", ")}`);
  182. 			}
  183. 			if (availableThemes) {
  184. 				log.verbose(`Available sap.ui.core themes: ${availableThemes.join(", ")}`);
  185. 			}
  186. 		}
  187. 		themeResources = themeResources.filter(isAvailable);
  188. 	}
  190. 	let processedResources;
  191. 	const useWorkers = !!taskUtil;
  192. 	if (useWorkers) {
  193. 		const threadMessageHandler = new FsMainThreadInterface(fsInterface(combo));
  195. 		processedResources = await Promise.all(themeResources.map(async (themeRes) => {
  196. 			const {port1, port2} = new MessageChannel();
  197. 			threadMessageHandler.startCommunication(port1);
  199. 			const result = await buildThemeInWorker(taskUtil, {
  200. 				fsInterfacePort: port2,
  201. 				themeResources: await serializeResources([themeRes]),
  202. 				options: {
  203. 					compress,
  204. 					cssVariables: !!cssVariables,
  205. 				},
  206. 			}, [port2]);
  208. 			threadMessageHandler.endCommunication(port1);
  210. 			return result;
  211. 		}))
  212. 			.then((resources) => Array.prototype.concat.apply([], resources))
  213. 			.then(deserializeResources);
  215. 		threadMessageHandler.cleanup();
  216. 	} else {
  217. 		// Do not use workerpool
  218. 		const themeBuilder = (await import("../processors/themeBuilder.js")).default;
  220. 		processedResources = await themeBuilder({
  221. 			resources: themeResources,
  222. 			fs: fsInterface(combo),
  223. 			options: {
  224. 				compress,
  225. 				cssVariables: !!cssVariables,
  226. 			}
  227. 		});
  228. 	}
  230. 	await Promise.all(processedResources.map((resource) => {
  231. 		return workspace.write(resource);
  232. 	}));
  233. }