@ui5/webcomponents-tools 0.0.0-b132dd7b9 → 0.0.0-b3a4f8020

package/lib/eslint/eslint.js

@@ -0,0 +1,44 @@
+const fs = require("fs");
+const { ESLint: ESLint7 } = require("eslint"); // isolated v7
+const path = require("path");
+
+const main = async argv => {
+	let eslintConfig;
+	if (fs.existsSync(".eslintrc.js") || fs.existsSync(".eslintrc.cjs")) {
+		// preferred way of custom configuration in root project folder
+		eslintConfig = null;
+	} else {
+		// no custom configuration - use default from tools project
+		eslintConfig = require.resolve("@ui5/webcomponents-tools/components-package/eslint.js")
+	};
+
+	const packageDir = path.dirname(require.resolve("@ui5/webcomponents-tools/package.json"));
+	const eslint = new ESLint7({
+		overrideConfigFile: eslintConfig,
+		fix: argv.includes("--fix"),
+		resolvePluginsRelativeTo: packageDir,
+	});
+	console.log("Running ESLint v7...");
+
+	// Lint files
+	const results = await eslint.lintFiles(["."]);
+
+	// Format results
+	const formatter = await eslint.loadFormatter("stylish");
+	const resultText = formatter.format(results);
+
+	// Output results
+	console.log(resultText);
+
+	// Exit with error code if there are errors
+	const hasErrors = results.some(result => result.errorCount > 0);
+	if (hasErrors) {
+		process.exit(1);
+	}
+}
+
+if (require.main === module) {
+	main(process.argv)
+}
+
+exports._ui5mainFn = main;

package/lib/generate-js-imports/illustrations.js

@@ -2,85 +2,86 @@ const fs = require("fs").promises;
 const path = require("path");
 
 const generateDynamicImportLines = async (fileNames, location, exclusionPatterns = []) => {
-  const packageName = JSON.parse(await fs.readFile("package.json")).name;
-  return fileNames
-    .filter((fileName) => !exclusionPatterns.some((pattern) => fileName.startsWith(pattern)))
-    .map((fileName) => {
-      const illustrationName = fileName.replace(".js", "");
-      const illustrationPath = `${location}/${illustrationName}`;
-      return `\t\tcase "${fileName.replace('.js', '')}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-${illustrationName.toLowerCase()}" */ "${illustrationPath}.js")).default;`;
-    })
-    .join("\n");
-};
-
-const generateAvailableIllustrationsArray = (fileNames, exclusionPatterns = []) => {
-  return JSON.stringify(
-    fileNames
-      .filter((fileName) => !exclusionPatterns.some((pattern) => fileName.startsWith(pattern)))
-      .map((fileName) => fileName.replace(".js", ""))
-  );
+	const packageName = JSON.parse(await fs.readFile("package.json")).name;
+	return fileNames
+		.filter((fileName) => !exclusionPatterns.some((pattern) => fileName.startsWith(pattern)))
+		.map((fileName) => {
+			const illustrationName = fileName.replace(".svg", "");
+			const illustrationPath = `${location}/${illustrationName}`;
+			return `\t\tcase "${fileName.replace('.js', '')}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-${illustrationName.toLowerCase()}" */ "${illustrationPath}.js")).default;`;
+		})
+		.join("\n");
 };
 
 const generateDynamicImportsFileContent = (dynamicImports, availableIllustrations, collection, set, prefix = "") => {
-  return `// @ts-nocheck
-  import { registerIllustrationLoader } from "@ui5/webcomponents-base/dist/asset-registries/Illustrations.js";
+	return `// @ts-nocheck
+import { registerIllustrationLoader } from "@ui5/webcomponents-base/dist/asset-registries/Illustrations.js";
 
 export const loadIllustration = async (illustrationName) => {
-  const collectionAndPrefix = "${set}/${collection}/${prefix}";
-  const cleanIllustrationName = illustrationName.startsWith(collectionAndPrefix) ? illustrationName.replace(collectionAndPrefix, "") : illustrationName;
-  switch (cleanIllustrationName) {
+	const collectionAndPrefix = "${set}/${collection}/${prefix}";
+	const cleanIllustrationName = illustrationName.startsWith(collectionAndPrefix) ? illustrationName.replace(collectionAndPrefix, "") : illustrationName;
+	switch (cleanIllustrationName) {
 ${dynamicImports}
-    default:
-      throw new Error("[Illustrations] Illustration not found: " + illustrationName);
-  }
+		default:
+			throw new Error("[Illustrations] Illustration not found: " + illustrationName);
+	}
 };
 
 const loadAndCheck = async (illustrationName) => {
-  const data = await loadIllustration(illustrationName);
-  return data;
+	const data = await loadIllustration(illustrationName);
+	return data;
 };
 
 ${availableIllustrations}.forEach((illustrationName) =>
-  registerIllustrationLoader(\`${set}/${collection}/${prefix}\${illustrationName}\`, loadAndCheck)
+	registerIllustrationLoader(\`${set}/${collection}/${prefix}\${illustrationName}\`, loadAndCheck)
 );
 `;
 };
 
 const getMatchingFiles = async (folder, pattern) => {
-  const dir = await fs.readdir(folder);
-  return dir.filter((fileName) => fileName.match(pattern));
+	const dir = await fs.readdir(folder);
+	return dir.filter((fileName) => fileName.match(pattern));
 };
 
-const generateIllustrations = async (config) => {
-  const { inputFolder, outputFile, collection, location, prefix, filterOut, set } = config;
+const generateIllustrations = async (argv) => {
+	const config = {
+		inputFolder: argv[2],
+		outputFile: argv[3],
+		set: argv[4],
+		collection: argv[5],
+		location: argv[6],
+		filterOut: argv[7].slice().split(","),
+	};
 
-  const normalizedInputFolder = path.normalize(inputFolder);
-  const normalizedOutputFile = path.normalize(outputFile);
 
-  const illustrations = await getMatchingFiles(normalizedInputFolder, /^.*\.js$/);
+	const { inputFolder, outputFile, collection, location, prefix, filterOut, set } = config;
 
-  const dynamicImports = await generateDynamicImportLines(illustrations, location, filterOut);
-  const availableIllustrations = generateAvailableIllustrationsArray(illustrations, filterOut);
+	const normalizedInputFolder = path.normalize(inputFolder);
+	const normalizedOutputFile = path.normalize(outputFile);
 
-  const contentDynamic = generateDynamicImportsFileContent(dynamicImports, availableIllustrations, collection, set, prefix);
+	const svgFiles = await getMatchingFiles(normalizedInputFolder, /\.svg$/);
 
-  await fs.mkdir(path.dirname(normalizedOutputFile), { recursive: true });
-  await fs.writeFile(normalizedOutputFile, contentDynamic);
+	const illustrations = [
+		...new Set(
+			svgFiles
+				.filter(name => !name.includes("sapIllus-Patterns"))
+				.map(name => name.split("-").pop().replace(".svg", ""))
+		),
+	];
 
-  console.log(`Generated ${normalizedOutputFile}`);
-};
+	const dynamicImports = await generateDynamicImportLines(illustrations, location, filterOut);
+	const contentDynamic = generateDynamicImportsFileContent(dynamicImports, JSON.stringify(illustrations), collection, set, prefix);
 
-// Parse configuration from command-line arguments
-const config = {
-  inputFolder: process.argv[2],
-  outputFile: process.argv[3],
-  set: process.argv[4],
-  collection: process.argv[5],
-  location: process.argv[6],
-  filterOut: process.argv.slice[7],
+	await fs.mkdir(path.dirname(normalizedOutputFile), { recursive: true });
+	await fs.writeFile(normalizedOutputFile, contentDynamic);
+
+	if (process.env.UI5_VERBOSE === "true") {
+		console.log("Generated illustration imports.");
+	}
 };
 
-// Run the generation process
-generateIllustrations(config).catch((error) => {
-  console.error("Error generating illustrations:", error);
-});
+if (require.main === module) {
+	generateIllustrations(process.argv)
+}
+
+exports._ui5mainFn = generateIllustrations;

package/lib/generate-json-imports/i18n.js

@@ -27,33 +27,36 @@ const importAndCheck = async (localeId) => {
 const localeIds = [${languagesKeysStringArray}];
 
 localeIds.forEach(localeId => {
-	registerI18nLoader("${packageName}", localeId, importAndCheck);
+	registerI18nLoader(${ packageName.split("").map(c => `"${c}"`).join (" + ") }, localeId, importAndCheck);
 });
 `;
 }
 
-const generate = async () => {
+const generate = async (argv) => {
 
 	const packageName = JSON.parse(await fs.readFile("package.json")).name;
 
-	const inputFolder = path.normalize(process.argv[2]);
-	const outputFileDynamic = path.normalize(`${process.argv[3]}/i18n.${ext}`);
-	const outputFileFetchMetaResolve = path.normalize(`${process.argv[3]}/i18n-fetch.${ext}`);
+	const inputFolder = path.normalize(argv[2]);
+	const outputFileDynamic = path.normalize(`${argv[3]}/i18n.${ext}`);
+	const outputFileFetchMetaResolve = path.normalize(`${argv[3]}/i18n-fetch.${ext}`);
+	const outputFileDynamicImportJSONImport = path.normalize(`${argv[3]}/i18n-node.${ext}`);
 
 	// All languages present in the file system
 	const files = await fs.readdir(inputFolder);
 	const languages = files.map(file => {
-		const matches = file.match(/messagebundle_(.+?).json$/);
+		const matches = file.match(/messagebundle_(.+?).properties$/);
 		return matches ? matches[1] : undefined;
 	}).filter(key => !!key);
 
 	let contentDynamic;
 	let contentFetchMetaResolve;
+	let contentDynamicImportJSONAttr;
 
 	// No i18n - just import dependencies, if any
 	if (languages.length === 0) {
 		contentDynamic = "";
 		contentFetchMetaResolve = "";
+		contentDynamicImportJSONAttr = "";
 	// There is i18n - generate the full file
 	} else {
 		// Keys for the array
@@ -62,21 +65,29 @@ const generate = async () => {
 		// Actual imports for json assets
 		const dynamicImportsString = languages.map(key => `		case "${key}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-messagebundle-${key}" */ "../assets/i18n/messagebundle_${key}.json")).default;`).join("\n");
 		const fetchMetaResolveString = languages.map(key => `		case "${key}": return (await fetch(new URL("../assets/i18n/messagebundle_${key}.json", import.meta.url))).json();`).join("\n");
+		const dynamicImportJSONAttrString = languages.map(key => `		case "${key}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-messagebundle-${key}" */ "../assets/i18n/messagebundle_${key}.json", {with: { type: 'json'}})).default;`).join("\n");
 
 		// Resulting file content
 
 		contentDynamic = getContent(dynamicImportsString, languagesKeysStringArray, packageName);
 		contentFetchMetaResolve = getContent(fetchMetaResolveString, languagesKeysStringArray, packageName);
-
+		contentDynamicImportJSONAttr = getContent(dynamicImportJSONAttrString, languagesKeysStringArray, packageName);
 	}
 
 	await fs.mkdir(path.dirname(outputFileDynamic), { recursive: true });
 	return Promise.all([
 		fs.writeFile(outputFileDynamic, contentDynamic),
 		fs.writeFile(outputFileFetchMetaResolve, contentFetchMetaResolve),
-	]);
+		fs.writeFile(outputFileDynamicImportJSONImport, contentDynamicImportJSONAttr),
+	]).then(() => {
+		if (process.env.UI5_VERBOSE === "true") {
+			console.log("Generated i18n JSON imports.");
+		}
+	});
 }
 
-generate().then(() => {
-	console.log("Generated i18n JSON imports.");
-});
+if (require.main === module) {
+	generate(process.argv)
+}
+
+exports._ui5mainFn = generate;

package/lib/generate-json-imports/themes.js

@@ -5,15 +5,18 @@ const assets = require("../../assets-meta.js");
 const isTypeScript = process.env.UI5_TS;
 const ext = isTypeScript ? 'ts' : 'js';
 
-const generate = async () => {
-	const inputFolder = path.normalize(process.argv[2]);
-	const outputFileDynamic = path.normalize(`${process.argv[3]}/Themes.${ext}`);
-	const outputFileFetchMetaResolve = path.normalize(`${process.argv[3]}/Themes-fetch.${ext}`);
+const CSS_VARIABLES_TARGET = process.env.CSS_VARIABLES_TARGET === "host";
 
-// All supported optional themes
+const generate = async (argv) => {
+	const inputFolder = path.normalize(argv[2]);
+	const outputFileDynamic = path.normalize(`${argv[3]}/Themes.${ext}`);
+	const outputFileDynamicImportJSONAttr = path.normalize(`${argv[3]}/Themes-node.${ext}`);
+	const outputFileFetchMetaResolve = path.normalize(`${argv[3]}/Themes-fetch.${ext}`);
+
+	// All supported optional themes
 	const allThemes = assets.themes.all;
 
-// All themes present in the file system
+	// All themes present in the file system
 	const dirs = await fs.readdir(inputFolder);
 	const themesOnFileSystem = dirs.map(dir => {
 		const matches = dir.match(/sap_.*$/);
@@ -24,9 +27,10 @@ const generate = async () => {
 
 	const availableThemesArray = `[${themesOnFileSystem.map(theme => `"${theme}"`).join(", ")}]`;
 	const dynamicImportLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-${theme.replace("_", "-")}-parameters-bundle" */"../assets/themes/${theme}/parameters-bundle.css.json")).default;`).join("\n");
+	const dynamicImportJSONAttrLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-${theme.replace("_", "-")}-parameters-bundle" */"../assets/themes/${theme}/parameters-bundle.css.json", {with: { type: 'json'}})).default;`).join("\n");
 	const fetchMetaResolveLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await fetch(new URL("../assets/themes/${theme}/parameters-bundle.css.json", import.meta.url))).json();`).join("\n");
 
-// dynamic imports file content
+	// dynamic imports file content
 	const contentDynamic = function (lines) {
 		return `// @ts-nocheck
 import { registerThemePropertiesLoader } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
@@ -47,17 +51,25 @@ const loadAndCheck = async (themeName) => {
 };
 
 ${availableThemesArray}
-  .forEach(themeName => registerThemePropertiesLoader("${packageName}", themeName, loadAndCheck));
+  .forEach(themeName => registerThemePropertiesLoader(${packageName.split("").map(c => `"${c}"`).join(" + ")}, themeName, loadAndCheck${CSS_VARIABLES_TARGET ? ', "host"' : ''}));
 `;
 	}
 
 	await fs.mkdir(path.dirname(outputFileDynamic), { recursive: true });
 	return Promise.all([
 		fs.writeFile(outputFileDynamic, contentDynamic(dynamicImportLines)),
+		fs.writeFile(outputFileDynamicImportJSONAttr, contentDynamic(dynamicImportJSONAttrLines)),
 		fs.writeFile(outputFileFetchMetaResolve, contentDynamic(fetchMetaResolveLines)),
-	]);
+	]).
+		then(() => {
+			if (process.env.UI5_VERBOSE === "true") {
+				console.log("Generated themes JSON imports.");
+			}
+		})
 };
 
-generate().then(() => {
-	console.log("Generated themes JSON imports.");
-});
+if (require.main === module) {
+	generate(process.argv)
+}
+
+exports._ui5mainFn = generate;

package/lib/i18n/defaults.js

@@ -3,14 +3,14 @@ const path = require('path');
 const PropertiesReader = require('properties-reader');
 const assets = require('../../assets-meta.js');
 
-const generate = async () => {
+const generate = async (argv) => {
 	const defaultLanguage = assets.languages.default;
 
-	const messageBundle = path.normalize(`${process.argv[2]}/messagebundle.properties`);
-	const messageBundleDefaultLanguage = path.normalize(`${process.argv[2]}/messagebundle_${defaultLanguage}.properties`);
+	const messageBundle = path.normalize(`${argv[2]}/messagebundle.properties`);
+	const messageBundleDefaultLanguage = path.normalize(`${argv[2]}/messagebundle_${defaultLanguage}.properties`);
 	const tsMode = process.env.UI5_TS === "true"; // In Typescript mode, we output .ts files and set the required types, otherwise - output pure .js files
 
-	const outputFile = path.normalize(`${process.argv[3]}/i18n-defaults.${tsMode ? "ts": "js"}`);
+	const outputFile = path.normalize(`${argv[3]}/i18n-defaults.${tsMode ? "ts" : "js"}`);
 
 	if (!messageBundle || !outputFile) {
 		return;
@@ -76,8 +76,15 @@ export {${textKeys.join()}};`;
 
 	await fs.mkdir(path.dirname(outputFile), { recursive: true });
 	await fs.writeFile(outputFile, getOutputFileContent(properties, defaultLanguageProperties));
+
+
+	if (process.env.UI5_VERBOSE === "true") {
+		console.log("i18n default file generated.");
+	}
 };
 
-generate().then(() => {
-	console.log("i18n default file generated.");
-});
+if (require.main === module) {
+	generate(process.argv)
+}
+
+exports._ui5mainFn = generate;

package/lib/i18n/toJSON.js

@@ -14,30 +14,58 @@ const assets = require('../../assets-meta.js');
 
 const allLanguages = assets.languages.all;
 
-const messagesBundles = path.normalize(`${process.argv[2]}/messagebundle_*.properties`);
-const messagesJSONDist = path.normalize(`${process.argv[3]}`);
+/**
+ * The translation system has a configuration whether to return UTF-8 sequences
+ * or the actual characters. This function inlines UTF-8 sequences to actual characters.
+ * 
+ * For example, it converts "Keine Produkte erf\u00FCgbar" to "Keine Produkte verfügbar"
+ * This makes the JSON files more readable and smaller.
+ */
+function inlineUTF(properties) {
+	for (const key in properties) {
+		if (Object.prototype.hasOwnProperty.call(properties, key)) {
+			try {
+				// escape double quotes to avoid JSON parse error
+				const escaped = properties[key].replaceAll("\"", "\\\"");
+				properties[key] = JSON.parse(`"${escaped}"`); // utilize JSON parser to decode UTF-8 sequences
+			} catch (e) {
+				// in case of error, just keep the original string
+				console.log(`Warning: failed to inline UTF-8 for key "${key}" with value "${properties[key]}"`);
+			}
+		}
+	}
+	return properties;
+}
 
-const convertToJSON = async (file) => {
-	const properties = PropertiesReader(file)._properties;
+const convertToJSON = async (file, distPath) => {
+	const properties = inlineUTF(PropertiesReader(file)._properties);
 	const filename = path.basename(file, path.extname(file));
 	const language = filename.match(/^messagebundle_(.*?)$/)[1];
 	if (!allLanguages.includes(language)) {
-		console.log("Not supported language: ", language);
-		return;
+		console.warn("Not supported language or script: ", language);
 	}
-	const outputFile = path.normalize(`${messagesJSONDist}/${filename}.json`);
+	const outputFile = path.normalize(`${distPath}/${filename}.json`);
 
 	return fs.writeFile(outputFile, JSON.stringify(properties));
 	// console.log(`[i18n]: "${filename}.json" has been generated!`);
 };
 
-const generate = async () => {
+const generate = async (agrv) => {
 	const { globby } = await import("globby");
+	const messagesBundles = path.normalize(`${agrv[2]}/messagebundle_*.properties`);
+	const messagesJSONDist = path.normalize(`${agrv[3]}`);
 	await fs.mkdir(messagesJSONDist, { recursive: true });
 	const files = await globby(messagesBundles.replace(/\\/g, "/"));
-	return Promise.all(files.map(convertToJSON));
+	return Promise.all(files.map(file => convertToJSON(file, messagesJSONDist)))
+		.then(() => {
+			if (process.env.UI5_VERBOSE === "true") {
+				console.log("Message bundle JSON files generated.");
+			}
+		});
 };
 
-generate().then(() => {
-	console.log("Message bundle JSON files generated.");
-});
+if (require.main === module) {
+	generate(process.argv)
+}
+
+exports._ui5mainFn = generate;

package/lib/icons-hash/icons-hash.mjs

@@ -0,0 +1,149 @@
+import fs from "fs/promises";
+import path from "path";
+import ignore from "ignore";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// -------------------
+// FNV-1a 32-bit hash
+// -------------------
+function fnv1aHash(str) {
+	let hash = 0x811c9dc5;
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.charCodeAt(i);
+		hash = (hash * 0x01000193) >>> 0;
+	}
+	return hash.toString(16);
+}
+
+async function findGitignoreFiles(startDir) {
+	const gitignores = [];
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		const candidate = path.join(currentDir, ".gitignore");
+		try {
+			await fs.access(candidate);
+			gitignores.push(candidate);
+		} catch { }
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return gitignores;
+}
+
+async function loadIgnoreRules(dir) {
+	const files = await findGitignoreFiles(dir);
+	const ig = ignore();
+	for (const file of files) {
+		const content = await fs.readFile(file, "utf8");
+		ig.add(content);
+	}
+	return ig;
+}
+
+async function walkDir(dir, ig, baseDir) {
+	const results = [];
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const absPath = path.join(dir, entry.name);
+		let relPath = path.relative(baseDir, absPath).replace(/\\/g, "/"); // normalize for .gitignore
+
+		if (ig.ignores(relPath) || relPath.startsWith("dist/")) continue;
+
+		if (entry.isDirectory()) {
+			results.push(...await walkDir(absPath, ig, baseDir));
+		} else {
+			results.push(relPath);
+		}
+	}
+	return results;
+}
+
+// Hash file content + mtime
+async function hashFile(filePath) {
+	const stat = await fs.stat(filePath);
+	const content = await fs.readFile(filePath, "utf8");
+	return fnv1aHash(String(stat.mtimeMs) + content);
+}
+
+function getRepoName(repoPath) {
+	return repoPath.split("/").pop();
+}
+
+async function computeHashes(repoPath, ig) {
+	const files = await walkDir(repoPath, ig, repoPath);
+	const hashEntries = await Promise.all(
+		files.map(async (file) => {
+			const absPath = path.join(repoPath, file);
+			const hash = await hashFile(absPath);
+			return [path.relative(process.cwd(), absPath), hash];
+		})
+	);
+	return Object.fromEntries(hashEntries);
+}
+
+async function saveHashes(repoPath, ig) {
+	const distPath = path.join(repoPath, "dist");
+	await fs.mkdir(distPath, { recursive: true });
+	const ui5iconsHashPath = path.join(distPath, ".ui5iconsHash");
+
+	// Cache the hashes for both the icons and tools packages, since the output depends on the content of both.
+	const hashes = {
+		...(await computeHashes(repoPath, ig)),
+		...(await computeHashes(path.resolve(__dirname, "../../"), ig)),
+	};
+
+	await fs.writeFile(ui5iconsHashPath, JSON.stringify(hashes, null, 2), "utf8");
+	console.log(`Saved build hashes for the ${getRepoName(repoPath)} package.`);
+}
+
+async function checkHashes(repoPath, ig) {
+	const ui5iconsHashPath = path.join(repoPath, "dist", ".ui5iconsHash");
+	let oldHashes = {};
+	try {
+		const raw = await fs.readFile(ui5iconsHashPath, "utf8");
+		oldHashes = JSON.parse(raw);
+	} catch {
+		console.log(`No build hashes found for the ${getRepoName(repoPath)} package. Building it now.`);
+		process.exit(1);
+	}
+
+	// Compare the hashes for both the icons and tools packages, since the output depends on the content of both.
+	const newHashes = {
+		...(await computeHashes(repoPath, ig)),
+		...(await computeHashes(path.resolve(__dirname, "../../"), ig)),
+	};
+
+	let changed = false;
+	for (const file of new Set([...Object.keys(oldHashes), ...Object.keys(newHashes)])) {
+		if (oldHashes[file] !== newHashes[file]) {
+			changed = true;
+		}
+	}
+
+	if (!changed) {
+		console.log(`No changes detected in the ${getRepoName(repoPath)} package.`);
+	} else {
+		console.log(`Changes detected in the ${getRepoName(repoPath)} package. Rebuilding it.`);
+		process.exit(1);
+	}
+}
+
+async function main() {
+	const mode = process.argv[2];
+	if (!["save", "check"].includes(mode)) {
+		throw new Error("Usage: node hashes.js <save|check>");
+	}
+
+	const repoPath = process.cwd();
+	const ig = await loadIgnoreRules(repoPath);
+
+	if (mode === "save") await saveHashes(repoPath, ig);
+	if (mode === "check") await checkHashes(repoPath, ig);
+}
+
+main().catch(console.error);

package/lib/remove-dev-mode/remove-dev-mode.mjs

@@ -1,37 +1,51 @@
 import { globby } from "globby";
 import * as esbuild from 'esbuild'
 import * as fs from "fs";
+import { pathToFileURL } from "url";
 
-let customPlugin = {
+const generate = async () => {
+  let customPlugin = {
     name: 'ui5-tools',
     setup(build) {
-        build.onLoad({ filter: /UI5Element.ts$/ }, async (args) => {
-          let text = await fs.promises.readFile(args.path, 'utf8');
-          text = text.replaceAll(/const DEV_MODE = true/g, "");
-          text = text.replaceAll(/if \(DEV_MODE\)/g, "if (false)");
-          return {
-            contents: text,
-            loader: 'ts',
-          }
-        })
-      },
-}
+      build.onLoad({ filter: /UI5Element.ts$/ }, async (args) => {
+        let text = await fs.promises.readFile(args.path, 'utf8');
+        text = text.replaceAll(/const DEV_MODE = true/g, "");
+        text = text.replaceAll(/if \(DEV_MODE\)/g, "if (false)");
+        return {
+          contents: text,
+          loader: 'ts',
+        }
+      })
+    },
+  }
 
-const getConfig = async () => {
+  const getConfig = async () => {
     const config = {
-        entryPoints: await globby("src/**/*.ts"),
-        bundle: false,
-        minify: true,
-        sourcemap: true,
-        outdir: 'dist/prod',
-        outbase: 'src',
-        plugins: [
-            customPlugin,
-        ]
+      entryPoints: await globby("src/**/*.ts"),
+      bundle: false,
+      minify: true,
+      sourcemap: true,
+      outdir: 'dist/prod',
+      outbase: 'src',
+      plugins: [
+        customPlugin,
+      ]
     };
     return config;
+  }
+
+
+  const config = await getConfig();
+  const result = await esbuild.build(config);
 }
 
+const filePath = process.argv[1];
+const fileUrl = pathToFileURL(filePath).href;
+
+if (import.meta.url === fileUrl) {
+  generate()
+}
 
-const config = await getConfig();
-const result = await esbuild.build(config);
+export default {
+  _ui5mainFn: generate
+}