@ui5/webcomponents-tools 0.0.0-cb061e041 → 0.0.0-ccb0705ac

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,22 @@ 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));
+
+
+	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/postcss-combine-duplicated-selectors/index.js

@@ -154,22 +154,29 @@ module.exports = (options) => {
 							options.removeDuplicatedProperties ||
 							options.removeDuplicatedValues
 						) {
-							removeDupProperties(
-								destination,
-								options.removeDuplicatedValues,
-							);
+							// removeDupProperties(
+							// 	destination,
+							// 	options.removeDuplicatedValues,
+							// );
 						}
 					} else {
 						if (
 							options.removeDuplicatedProperties ||
 							options.removeDuplicatedValues
 						) {
-							removeDupProperties(rule, options.removeDuplicatedValues);
+							// removeDupProperties(rule, options.removeDuplicatedValues);
 						}
 						// add new selector to symbol table
 						map.set(selector, rule);
 					}
 				},
+				OnceExit(root) {
+					root.nodes.forEach(node => {
+						if (node.type === "rule") {
+							removeDupProperties(node, options.removeDuplicatedValues);
+						}
+					})
+				}
 			};
 		},
 	};

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

@@ -0,0 +1,51 @@
+import { globby } from "globby";
+import * as esbuild from 'esbuild'
+import * as fs from "fs";
+import { pathToFileURL } from "url";
+
+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',
+        }
+      })
+    },
+  }
+
+  const getConfig = async () => {
+    const config = {
+      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()
+}
+
+export default {
+  _ui5mainFn: generate
+}

package/lib/rimraf/rimraf.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const path = require('path');
+
+const rimraf = dir => {
+	if (fs.existsSync(dir)) {
+		fs.readdirSync(dir).forEach(entry => {
+			const entryPath = path.join(dir, entry);
+			if (fs.lstatSync(entryPath).isDirectory()) {
+				rimraf(entryPath);
+			} else {
+				fs.unlinkSync(entryPath);
+			}
+		});
+		fs.rmdirSync(dir);
+	}
+};
+
+const main = argv => {
+	if (argv.length < 3) {
+		console.error("rimraf <dir>");
+		process.exit(1);
+	}
+	const dir = argv[2];
+	rimraf(dir);
+};
+
+if (require.main === module) {
+	main(process.argv)
+}
+
+exports._ui5mainFn = main;

package/lib/scoping/get-all-tags.js

@@ -4,13 +4,20 @@ const glob = require("glob");
 
 const getTag = file => {
 	const fileContent = String(fs.readFileSync(file)).replace(/\n/g, "");
-	const matches = fileContent.match(/\btag\b:\s*\"(.*?)\"/);
-	return matches ? matches[1] : undefined;
+	let matches = fileContent.match(/\btag\b:\s*\"(.*?)\"/);
+	if (matches) {
+		return matches[1];
+	}
+	matches = fileContent.match(/@customElement\("(.*?)"\)/);
+	if (matches) {
+		return matches[1];
+	}
+	return undefined;
 };
 
 const getPackageTags = (packageDir) => {
 	const srcDir = path.join(packageDir, "src/");
-	return glob.sync(path.join(srcDir, "/**/*.js")).flatMap(file => {
+	return glob.sync(path.join(srcDir, "/**/*.ts")).flatMap(file => {
 		const tag = getTag(file);
 		return [tag];
 	}).filter(item => !!item);

package/lib/scoping/lint-src.js

@@ -7,25 +7,26 @@ const tags = getAllTags(process.cwd());
 
 const errors = [];
 
+const removeComments = str => str.replaceAll(/\/\*[\s\S]*?\*\/|([^:]|^)\/\/.*$/gm, "");
+
 glob.sync(path.join(process.cwd(), "src/**/*.css")).forEach(file => {
-	let content = String(fs.readFileSync(file));
+	let content = removeComments(String(fs.readFileSync(file)));
 	tags.forEach(tag => {
 		if (content.match(new RegExp(`(^|[^\.\-_A-Za-z0-9"\[])(${tag})([^\-_A-Za-z0-9]|$)`, "g"))) {
-			errors.push(`Warning! ${tag} found in ${file}`);
+			errors.push(`${tag} found in ${file}`);
 		}
 	});
 });
 
-glob.sync(path.join(process.cwd(), "src/**/*.js")).forEach(file => {
-	let content = String(fs.readFileSync(file));
+glob.sync(path.join(process.cwd(), "src/**/*.ts")).forEach(file => {
+	let content = removeComments(String(fs.readFileSync(file)));
 	tags.forEach(tag => {
 		if (content.match(new RegExp(`querySelector[A-Za-z]*..${tag}`, "g"))) {
-			errors.push(`Warning! querySelector for ${tag} found in ${file}`);
+			errors.push(`querySelector for ${tag} found in ${file}`);
 		}
 	});
 });
 
 if (errors.length) {
-	errors.forEach(error => console.log(error));
-	throw new Error("Errors found.");
+	throw new Error(`Scoping-related errors found (f.e. used ui5-input instead of [ui5-input]): \n ${errors.join("\n")}`);
 }

package/lib/scoping/scope-test-pages.js

@@ -18,6 +18,7 @@ const replaceTagsHTML = content => {
 
 // Replace tags in any content
 const replaceTagsAny = content => {
+	console.log(tags.length);
 	tags.forEach(tag => {
 		content = content.replace(new RegExp(`(^|[^\-_A-Za-z0-9])(${tag})([^\-_A-Za-z0-9]|$)`, "g"), `$1$2-${suffix}$3`);
 	});
@@ -27,7 +28,7 @@ const replaceTagsAny = content => {
 // Replace bundle names and HTML tag names in test pages
 glob.sync(path.join(root, "/**/*.html")).forEach(file => {
 	let content = String(fs.readFileSync(file));
-	content = content.replace(/bundle\.(.*?)\.js/g, `../bundle.scoped.$1.js`);
+	content = content.replace("%VITE_BUNDLE_PATH%", "%VITE_BUNDLE_PATH_SCOPED%");
 	content = replaceTagsHTML(content);
 	fs.writeFileSync(file, content);
 });

package/lib/test-runner/test-runner.js

@@ -3,69 +3,77 @@ const { readFileSync } = require("fs");
 const path = require("path");
 const fs = require("fs");
 
-// search for dev-server port 
+function testFn(outArgv) {
+// search for dev-server port
 // start in current folder
 // traversing upwards in case of mono repo tests and dev-server running in root folder of repository
-let devServerFolder = process.cwd();
-let devServerPort;
-while (true) {
-    try {
-        devServerPort = readFileSync(path.join(devServerFolder, ".dev-server-port")).toString();
-        break; // found
-    } catch (e) {
-        // file not found
-        if (devServerFolder === path.dirname(devServerFolder)) {
-            break; // reached root folder "/"
-        }
-        devServerFolder = path.dirname(devServerFolder);
-    }
-}
+	let devServerFolder = process.cwd();
+	let devServerPort;
+	while (true) {
+		try {
+			devServerPort = readFileSync(path.join(devServerFolder, ".dev-server-port")).toString();
+			break; // found
+		} catch (e) {
+			// file not found
+			if (devServerFolder === path.dirname(devServerFolder)) {
+				break; // reached root folder "/"
+			}
+			devServerFolder = path.dirname(devServerFolder);
+		}
+	}
 
 // check if we are in a monorepo and extract path from package.json
-let packageRepositoryPath = "";
-const pkg = require(path.join(process.cwd(), "package.json"));
-packageRepositoryPath = pkg.repository ? pkg.repository.directory : "";
+	let packageRepositoryPath = "";
+	const pkg = require(path.join(process.cwd(), "package.json"));
+	packageRepositoryPath = pkg.repository ? pkg.repository.directory : "";
 
 // construct base url
 // use devServerPort if a dev server is running, otherwise let the baseUrl in the wdio config be used
 // if a dev server is running in the root of a mono repo, append tha package path like this
 // http://localhost:${devServerPort}/packages/main/
-let baseUrl = "";
-if (devServerPort) {
-    console.log(`Found port ${devServerPort} from '${path.join(devServerFolder, ".dev-server-port")}'`);
-    const devServerInRoot = !devServerFolder.includes(packageRepositoryPath);
-    if (devServerInRoot) {
-        baseUrl = `--base-url http://localhost:${devServerPort}/${packageRepositoryPath}/`;
-    } else {
-        baseUrl = `--base-url http://localhost:${devServerPort}/`;
-    }
-}
+	let baseUrl = "";
+	if (devServerPort) {
+		console.log(`Found port ${devServerPort} from '${path.join(devServerFolder, ".dev-server-port")}'`);
+		const devServerInRoot = !devServerFolder.includes(packageRepositoryPath);
+		if (devServerInRoot) {
+			baseUrl = `--base-url http://localhost:${devServerPort}/${packageRepositoryPath}/`;
+		} else {
+			baseUrl = `--base-url http://localhost:${devServerPort}/`;
+		}
+	}
 
-if (!baseUrl) {
-    console.log("No dev server running, running tests served from `dist`, make sure it is up to date");
-}
+	if (!baseUrl) {
+		console.log("No dev server running, running tests served from `dist`, make sure it is up to date");
+	}
 
 // add single spec parameter if passed
-let spec = "";
-if (process.argv.length === 3) {
-    const specFile = process.argv[2];
-    spec = `--spec ${specFile}`;
-}
+	let spec = "";
+	if (outArgv.length === 3) {
+		const specFile = outArgv[2];
+		spec = `--spec ${specFile}`;
+	}
 
 // more parameters - pass them to wdio
-let restParams = "";
-if (process.argv.length > 3) {
-    restParams = process.argv.slice(2).join(" ");
+	let restParams = "";
+	if (outArgv.length > 3) {
+		restParams = outArgv.slice(2).join(" ");
+	}
+
+	let wdioConfig = "";
+	if (fs.existsSync("config/wdio.conf.cjs")) {
+		wdioConfig = "config/wdio.conf.cjs";
+	} else if (fs.existsSync("config/wdio.conf.js")) {
+		wdioConfig = "config/wdio.conf.js";
+	}
+
+// run wdio with calculated parameters
+	const cmd = `npx cross-env WDIO_LOG_LEVEL=error wdio ${wdioConfig} ${spec} ${baseUrl} ${restParams}`;
+	console.log(`executing: ${cmd}`);
+	child_process.execSync(cmd, {stdio: 'inherit'});
 }
 
-let wdioConfig = "";
-if (fs.existsSync("config/wdio.conf.cjs")) {
-    wdioConfig = "config/wdio.conf.cjs";
-} else if (fs.existsSync("config/wdio.conf.js")) {
-    wdioConfig = "config/wdio.conf.js";
+if (require.main === module) {
+	testFn(process.argv)
 }
 
-// run wdio with calculated parameters
-const cmd = `yarn cross-env WDIO_LOG_LEVEL=error wdio ${wdioConfig} ${spec} ${baseUrl} ${restParams}`;
-console.log(`executing: ${cmd}`);
-child_process.execSync(cmd, {stdio: 'inherit'});
+exports._ui5mainFn = testFn;