@ui5/webcomponents-tools 0.0.0-07d38e78e → 0.0.0-093de5dd1

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

@@ -2,85 +2,84 @@ 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);
+
+	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

@@ -4,68 +4,88 @@ const path = require('path');
 const isTypeScript = process.env.UI5_TS;
 const ext = isTypeScript ? 'ts' : 'js';
 
-const generate = async () => {
+
+const getContent = function(caseLines, languagesKeysStringArray, packageName) {
+	return `// @ts-nocheck
+import { registerI18nLoader } from "@ui5/webcomponents-base/dist/asset-registries/i18n.js";
+
+const importMessageBundle = async (localeId) => {
+	switch (localeId) {
+		${caseLines}
+		default: throw "unknown locale"
+	}
+}
+
+const importAndCheck = async (localeId) => {
+	const data = await importMessageBundle(localeId);
+	if (typeof data === "string" && data.endsWith(".json")) {
+		throw new Error(\`[i18n] Invalid bundling detected - dynamic JSON imports bundled as URLs. Switch to inlining JSON files from the build. Check the \"Assets\" documentation for more information.\`);
+	}
+	return data;
+}
+
+const localeIds = [${languagesKeysStringArray}];
+
+localeIds.forEach(localeId => {
+	registerI18nLoader(${ packageName.split("").map(c => `"${c}"`).join (" + ") }, localeId, importAndCheck);
+});
+`;
+}
+
+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 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
+	// 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
+	// No i18n - just import dependencies, if any
 	if (languages.length === 0) {
 		contentDynamic = "";
-// There is i18n - generate the full file
+		contentFetchMetaResolve = "";
+		contentDynamicImportJSONAttr = "";
+	// There is i18n - generate the full file
 	} else {
 		// Keys for the array
 		const languagesKeysStringArray = languages.map(key => `"${key}",`).join("\n\t");
 
 		// 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 = `// @ts-nocheck
-import { registerI18nLoader } from "@ui5/webcomponents-base/dist/asset-registries/i18n.js";
-
-	const importMessageBundle = async (localeId) => {
-		switch (localeId) {
-	${dynamicImportsString}
-			default: throw "unknown locale"
-		}
-	}
-
-	const importAndCheck = async (localeId) => {
-		const data = await importMessageBundle(localeId);
-		if (typeof data === "string" && data.endsWith(".json")) {
-			throw new Error(\`[i18n] Invalid bundling detected - dynamic JSON imports bundled as URLs. Switch to inlining JSON files from the build. Check the \"Assets\" documentation for more information.\`);
-		}
-		return data;
-	}
-
-	const localeIds = [${languagesKeysStringArray}];
-
-	localeIds.forEach(localeId => {
-		registerI18nLoader("${packageName}", localeId, importAndCheck);
-	});
-	`;
-
 
+		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(() => {
+		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,14 +5,16 @@ 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 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
+	// 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_.*$/);
@@ -23,14 +25,17 @@ 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
-	const contentDynamic = `// @ts-nocheck
+	// dynamic imports file content
+	const contentDynamic = function (lines) {
+		return `// @ts-nocheck
 import { registerThemePropertiesLoader } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
 
 const loadThemeProperties = async (themeName) => {
 	switch (themeName) {
-${dynamicImportLines}
+${lines}
 		default: throw "unknown theme"
 	}
 };
@@ -44,15 +49,23 @@ const loadAndCheck = async (themeName) => {
 };
 
 ${availableThemesArray}
-  .forEach(themeName => registerThemePropertiesLoader("${packageName}", themeName, loadAndCheck));
+  .forEach(themeName => registerThemePropertiesLoader(${packageName.split("").map(c => `"${c}"`).join(" + ")}, themeName, loadAndCheck));
 `;
+	}
 
 	await fs.mkdir(path.dirname(outputFileDynamic), { recursive: true });
 	return Promise.all([
-		fs.writeFile(outputFileDynamic, contentDynamic)
-	]);
+		fs.writeFile(outputFileDynamic, contentDynamic(dynamicImportLines)),
+		fs.writeFile(outputFileDynamicImportJSONAttr, contentDynamic(dynamicImportJSONAttrLines)),
+		fs.writeFile(outputFileFetchMetaResolve, contentDynamic(fetchMetaResolveLines)),
+	]).
+		then(() => {
+			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/hbs2ui5/RenderTemplates/LitRenderer.js

@@ -3,11 +3,11 @@ const tsImports = (controlName, hasTypes) => {
 		return "";
 	}
 
-	const importPrefix = process.env.UI5_BASE ? "../../../" : "@ui5/webcomponents-base/dist/"
+	const importPrefix = process.env.UI5_BASE ? "../../../../../src/" : "@ui5/webcomponents-base/dist/"
 
 	return `import type UI5Element from "${importPrefix}UI5Element.js";
-	${importForControl(controlName, hasTypes)}
-	import type { ClassMapValue } from "${importPrefix}types.js";
+${importForControl(controlName, hasTypes)}
+import type { ClassMapValue } from "${importPrefix}types.js";
 	`;
 }
 const importForControl = (controlName, hasTypes) => {
@@ -18,21 +18,26 @@ const importForControl = (controlName, hasTypes) => {
 
 	if (process.env.UI5_BASE) {
 		// base package has a component in `test/elements` instead of `src`
-		return `import type ${controlName} from "../../../../test/elements/${controlName}.js";`
+		return `import type ${controlName} from "../../../${controlName}.js";`
 	}
 	return `import type ${controlName} from "../../${controlName}.js";`
 }
 
 const buildRenderer = (controlName, litTemplate, hasTypes) => {
-	const importPrefix = process.env.UI5_BASE ? "../../../" : "@ui5/webcomponents-base/dist/"
+	const importPrefix = process.env.UI5_BASE ? "../../../../../src/" : "@ui5/webcomponents-base/dist/";
+
+	const mainTemplateFunction = process.env.UI5_TS ?
+		`function template(this: ${controlName}) { return block0.call(this, this, (this.constructor as typeof UI5Element).tagsToScope, getCustomElementsScopingSuffix()); }` :
+		`function template() { return block0.call(this, this, this.constructor.tagsToScope, getCustomElementsScopingSuffix()); }`;
 
 	// typescript cannot process package imports for the same package and the paths are changed to relative for base package templates
 	return `/* eslint no-unused-vars: 0 */
 import { html, svg, repeat, classMap, styleMap, ifDefined, unsafeHTML, scopeTag } from "${importPrefix}renderer/LitRenderer.js";
+import { getCustomElementsScopingSuffix } from "${importPrefix}CustomElementsScopeUtils.js";
 ${tsImports(controlName, hasTypes)}
 ${litTemplate}
-
-export default block0;`;
+${mainTemplateFunction}
+export default template;`;
 };
 
 module.exports = {

package/lib/hbs2ui5/index.js

@@ -24,7 +24,7 @@ const onError = (place) => {
 	console.log(`A problem occoured when reading ${place}. Please recheck passed parameters.`);
 };
 
-const isHandlebars = (fileName) => fileName.indexOf('.hbs') !== -1;
+const isHandlebars = (fileName) => fileName.endsWith('.hbs');
 
 const hasTypes = (file, componentName) => {
 	const tsFile = path.join(path.dirname(file), componentName + ".ts")
@@ -36,7 +36,7 @@ const processFile = async (file, outputDir) => {
 	const componentNameMatcher = /(\w+)(\.hbs)/gim;
 	const componentName = componentNameMatcher.exec(file)[1];
 	const componentHasTypes = hasTypes(file, componentName);
-	if (!componentHasTypes) { 
+	if (!componentHasTypes) {
 		if (!missingTypesReported) {
 			console.warn("[Warn] The following templates do not have a corresponging .ts or .d.ts file and won't be type checked:")
 			missingTypesReported = true;
@@ -98,7 +98,7 @@ const writeRenderers = async (outputDir, controlName, fileContent) => {
 
 		let existingFileContent = "";
 		try {
-			existingFileContent = await fs.readFile(compiledFilePath);
+			existingFileContent = (await fs.readFile(compiledFilePath)).toString();
 		} catch (e) {}
 
 		if (existingFileContent !== fileContentUnix) {

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;
@@ -31,7 +31,8 @@ const generate = async () => {
 	// (2) as the messagebundle.properties file is always written in English,
 	// it makes sense to consider the messagebundle.properties content only when the default language is "en".
 	if (defaultLanguage === "en") {
-		defaultLanguageProperties = Object.assign({}, defaultLanguageProperties, properties);
+		// use messagebundle_en.properties to overwrite all developer properties, only the not translated ones will remain
+		defaultLanguageProperties = Object.assign({}, properties, defaultLanguageProperties);
 	}
 
 	/*
@@ -68,15 +69,20 @@ const generate = async () => {
 		const texts = textKeys.map(prop => getTextInfo(prop, properties[prop], defaultLanguageProperties && defaultLanguageProperties[prop])).join('');
 
 		// tabs are intentionally mixed to have proper identation in the produced file
-		return `${tsMode ? `import { I18nText } from "@ui5/webcomponents-base/dist/i18nBundle.js";` : ""}
+		return `${tsMode ? `import type { I18nText } from "@ui5/webcomponents-base/dist/i18nBundle.js";` : ""}
 ${texts}
 export {${textKeys.join()}};`;
 	};
 
 	await fs.mkdir(path.dirname(outputFile), { recursive: true });
 	await fs.writeFile(outputFile, getOutputFileContent(properties, defaultLanguageProperties));
+
+
+	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,56 @@ 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(() => {
+			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;