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

package/lib/cem/custom-elements-manifest.config.mjs

@@ -4,6 +4,7 @@ import path from "path";
 import fs from 'fs';
 import {
 	getDeprecatedStatus,
+	getExperimentalStatus,
 	getSinceStatus,
 	getPrivacyStatus,
 	getReference,
@@ -26,6 +27,17 @@ import { generateCustomData } from "cem-plugin-vs-code-custom-data-generator";
 import { customElementJetBrainsPlugin } from "custom-element-jet-brains-integration";
 
 const packageJSON = JSON.parse(fs.readFileSync("./package.json"));
+let aliasMap = {};
+
+const devMode = process.env.UI5_CEM_MODE === "dev";
+try {
+	aliasMap = JSON.parse(fs.readFileSync("./.ui5-cem-aliases.json"));
+} catch (e) {
+	if (devMode) {
+		console.warn("No .ui5-cem-aliases.json file found. Continuing without aliases.");
+	}
+}
+
 
 const extractClassNodeJSDoc = node => {
 	const fileContent = node.getFullText();
@@ -64,12 +76,23 @@ function processClass(ts, classNode, moduleDoc) {
 	currClass.customElement = !!customElementDecorator || className === "UI5Element" || undefined;
 	currClass.kind = "class";
 	currClass.deprecated = getDeprecatedStatus(classParsedJsDoc);
+	currClass._ui5experimental = getExperimentalStatus(classParsedJsDoc);
 	currClass._ui5since = getSinceStatus(classParsedJsDoc);
 	currClass._ui5privacy = getPrivacyStatus(classParsedJsDoc);
 	currClass._ui5abstract = hasTag(classParsedJsDoc, "abstract") ? true : undefined;
 	currClass.description = normalizeDescription(classParsedJsDoc.description || findTag(classParsedJsDoc, "class")?.description);
 	currClass._ui5implements = findAllTags(classParsedJsDoc, "implements")
-		.map(tag => getReference(ts, normalizeTagType(tag.type), classNode, moduleDoc.path))
+		.map(tag => {
+			const correctInterfaceDescription = classNode?.heritageClauses?.some(heritageClause => {
+				return heritageClause?.types?.some(type => type.expression?.text === normalizeTagType(tag.type));
+			});
+
+			if (!correctInterfaceDescription) {
+				logDocumentationError(moduleDoc.path, `@interface {${tag.type}} tag is used, but the class doesn't implement the corresponding interface`)
+			}
+
+			return getReference(ts, normalizeTagType(tag.type), classNode, moduleDoc.path)
+		})
 		.filter(Boolean);
 
 
@@ -77,6 +100,10 @@ function processClass(ts, classNode, moduleDoc) {
 		const superclassTag = findTag(classParsedJsDoc, "extends");
 		currClass.superclass = getReference(ts, superclassTag.name, classNode, moduleDoc.path);
 
+		if (classNode?.heritageClauses?.[0]?.types?.[0]?.expression?.text !== superclassTag.name) {
+			logDocumentationError(moduleDoc.path, `@extends ${superclassTag.name} is used, but the class doesn't extend the corresponding superclass`)
+		}
+
 		if (currClass.superclass?.name === "UI5Element") {
 			currClass.customElement = true;
 		}
@@ -111,9 +138,13 @@ function processClass(ts, classNode, moduleDoc) {
 	}
 
 	// Events
-	currClass.events = findAllDecorators(classNode, "event")
+	currClass.events = findAllDecorators(classNode, ["event", "eventStrict"])
 		?.map(event => processEvent(ts, event, classNode, moduleDoc));
 
+	const filename = classNode.getSourceFile().fileName;
+	const sourceFile = typeProgram.getSourceFile(filename);
+	const tsProgramClassNode = sourceFile.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === classNode.name?.text);
+
 	// Slots (with accessor), methods and fields
 	for (let i = 0; i < (currClass.members?.length || 0); i++) {
 		const member = currClass.members[i];
@@ -168,17 +199,21 @@ function processClass(ts, classNode, moduleDoc) {
 				const propertyDecorator = findDecorator(classNodeMember, "property");
 
 				if (propertyDecorator) {
-					member._ui5validator = propertyDecorator?.expression?.arguments[0]?.properties?.find(property => ["validator", "type"].includes(property.name.text))?.initializer?.text || "String";
 					member._ui5noAttribute = propertyDecorator?.expression?.arguments[0]?.properties?.find(property => property.name.text === "noAttribute")?.initializer?.kind === ts.SyntaxKind.TrueKeyword || undefined;
 				}
 
-				if (currClass.customElement && member.privacy === "public" && !propertyDecorator?.expression?.arguments[0]?.properties?.find(property => property.name.text === "multiple") && !["object"].includes(member._ui5validator?.toLowerCase())) {
-					const filename = classNode.getSourceFile().fileName;
-					const sourceFile = typeProgram.getSourceFile(filename);
-					const tsProgramClassNode = sourceFile.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === classNode.name?.text);
+				if (currClass.customElement && member.privacy === "public") {
 					const tsProgramMember = tsProgramClassNode.members.find(m => ts.isPropertyDeclaration(m) && m.name?.text === member.name);
 					const attributeValue = typeChecker.typeToString(typeChecker.getTypeAtLocation(tsProgramMember), tsProgramMember);
 
+					if (attributeValue === "boolean" && member.default === "true") {
+						logDocumentationError(moduleDoc.path, `Boolean properties must be initialzed to false. [${member.name}] property of class [${className}] is intialized to \`true\``)
+					}
+
+					if (!member.type) {
+						logDocumentationError(moduleDoc.path, `Public properties must have type. The type of [${member.name}] property is not determinated automatically. Please check it.`)
+					}
+
 					currClass.attributes.push({
 						description: member.description,
 						name: toKebabCase(member.name),
@@ -293,6 +328,7 @@ function processInterface(ts, interfaceNode, moduleDoc) {
 		kind: "interface",
 		name: interfaceName,
 		description: normalizeDescription(interfaceParsedJsDoc?.description),
+		_ui5experimental: getExperimentalStatus(interfaceParsedJsDoc),
 		_ui5privacy: getPrivacyStatus(interfaceParsedJsDoc),
 		_ui5since: getSinceStatus(interfaceParsedJsDoc),
 		deprecated: getDeprecatedStatus(interfaceParsedJsDoc),
@@ -313,6 +349,7 @@ function processEnum(ts, enumNode, moduleDoc) {
 		kind: "enum",
 		name: enumName,
 		description: normalizeDescription(enumJSdoc?.comment),
+		_ui5experimental: getExperimentalStatus(enumParsedJsDoc),
 		_ui5privacy: getPrivacyStatus(enumParsedJsDoc),
 		_ui5since: getSinceStatus(enumParsedJsDoc),
 		deprecated: getDeprecatedStatus(enumParsedJsDoc) || undefined,
@@ -425,14 +462,6 @@ export default {
 				}
 			},
 			moduleLinkPhase({ moduleDoc }) {
-				for (let i = 0; i < moduleDoc.declarations.length; i++) {
-					const shouldRemove = processPublicAPI(moduleDoc.declarations[i]) || ["function", "variable"].includes(moduleDoc.declarations[i].kind)
-					if (shouldRemove) {
-						moduleDoc.declarations.splice(i, 1);
-						i--;
-					}
-				}
-
 				moduleDoc.path = moduleDoc.path?.replace(/^src/, "dist").replace(/\.ts$/, ".js");
 
 				moduleDoc.exports = moduleDoc.exports.
@@ -456,41 +485,57 @@ export default {
 						})
 					}
 				})
+			},
+			packageLinkPhase({ customElementsManifest }) {
+				customElementsManifest.modules.forEach(moduleDoc => {
+					for (let i = 0; i < moduleDoc.declarations.length; i++) {
+						const shouldRemove = processPublicAPI(moduleDoc.declarations[i]) || ["function", "variable"].includes(moduleDoc.declarations[i].kind)
+						if (shouldRemove) {
+							moduleDoc.declarations.splice(i, 1);
+							i--;
+						}
+					}
 
-				const typeReferences = new Set();
-				const registerTypeReference = reference => typeReferences.add(JSON.stringify(reference))
-
-				moduleDoc.declarations.forEach(declaration => {
-					["events", "slots", "members"].forEach(memberType => {
-						declaration[memberType]?.forEach(member => {
-							if (member.type?.references) {
-								member.type.references.forEach(registerTypeReference)
-							} else if (member._ui5type?.references) {
-								member._ui5type.references.forEach(registerTypeReference)
-							} else if (member.kind === "method") {
-								member.return?.type?.references?.forEach(registerTypeReference)
-
-								member.parameters?.forEach(parameter => {
-									parameter.type?.references?.forEach(registerTypeReference)
-								})
-							}
-						})
+					moduleDoc.declarations.forEach(declaration => {
+						if (declaration.superclass?.name && aliasMap[declaration.superclass.name]) {
+							declaration.superclass.name = aliasMap[declaration.superclass.name];
+						}
 					})
-				});
 
-				typeReferences.forEach(reference => {
-					reference = JSON.parse(reference);
-					if (reference.package === packageJSON?.name && reference.module === moduleDoc.path) {
-						const hasExport = moduleDoc.exports.some(e => e.declaration?.name === reference.name && e.declaration?.module === reference.module)
+					const typeReferences = new Set();
+					const registerTypeReference = reference => typeReferences.add(JSON.stringify(reference))
+
+					moduleDoc.declarations.forEach(declaration => {
+						["events", "slots", "members"].forEach(memberType => {
+							declaration[memberType]?.forEach(member => {
+								if (member.type?.references) {
+									member.type.references.forEach(registerTypeReference)
+								} else if (member._ui5type?.references) {
+									member._ui5type.references.forEach(registerTypeReference)
+								} else if (member.kind === "method") {
+									member.return?.type?.references?.forEach(registerTypeReference)
+
+									member.parameters?.forEach(parameter => {
+										parameter.type?.references?.forEach(registerTypeReference)
+									})
+								}
+							})
+						})
+					});
+
+					typeReferences.forEach(reference => {
+						reference = JSON.parse(reference);
+						if (reference.package === packageJSON?.name && reference.module === moduleDoc.path) {
+							const hasExport = moduleDoc.exports.some(e => e.declaration?.name === reference.name && e.declaration?.module === reference.module)
 
-						if (!hasExport) {
-							logDocumentationError(moduleDoc.path?.replace(/^dist/, "src").replace(/\.js$/, ".ts"), `Type '${reference.name}' is used to describe a public API but is not exported.`,)
+							if (!hasExport) {
+								logDocumentationError(moduleDoc.path?.replace(/^dist/, "src").replace(/\.js$/, ".ts"), `Type '${reference.name}' is used to describe a public API but is not exported.`,)
+							}
 						}
-					}
-				})
-			},
-			packageLinkPhase({ context }) {
-				if (context.dev) {
+					})
+				});
+
+				if (devMode) {
 					displayDocumentationErrors();
 				}
 			}

package/lib/cem/event.mjs

@@ -16,19 +16,10 @@ import {
 } from "./utils.mjs";
 
 const jsDocRegExp = /\/\*\*(.|\n)+?\s+\*\//;
+const ASTFalseKeywordCode = 94;
 
 const getParams = (ts, eventDetails, commentParams, classNode, moduleDoc) => {
 	return commentParams?.map(commentParam => {
-		const decoratorParam = eventDetails?.find(prop => prop?.name?.text === commentParam?.name);
-
-		if (!decoratorParam || !decoratorParam?.jsDoc?.[0]) {
-			return;
-		}
-
-		const decoratorParamParsedComment = parse(decoratorParam?.jsDoc?.[0]?.getText?.(), { spacing: 'preserve' })[0];
-
-		validateJSDocComment("eventParam", decoratorParamParsedComment, decoratorParam.name?.text, moduleDoc);
-
 		const { typeName, name } = getType(normalizeTagType(commentParam?.type));
 		let type;
 
@@ -47,12 +38,10 @@ const getParams = (ts, eventDetails, commentParams, classNode, moduleDoc) => {
 		return {
 			type,
 			name: commentParam?.name,
-			_ui5privacy: getPrivacyStatus(decoratorParamParsedComment),
+			_ui5privacy: "public",
 			description: normalizeDescription(commentParam?.description),
-			_ui5since: getSinceStatus(decoratorParamParsedComment),
-			deprecated: getDeprecatedStatus(decoratorParamParsedComment),
 		};
-	}).filter(pair => !!pair);
+	});
 };
 
 function processEvent(ts, event, classNode, moduleDoc) {
@@ -77,30 +66,32 @@ function processEvent(ts, event, classNode, moduleDoc) {
 	const privacy = findTag(eventParsedComment, ["public", "private", "protected"])?.tag || "private";
 	const sinceTag = findTag(eventParsedComment, "since");
 	const commentParams = findAllTags(eventParsedComment, "param");
-	const allowPreventDefault = hasTag(eventParsedComment, "allowPreventDefault") || undefined;
 	const description = normalizeDescription(eventParsedComment?.description);
 	const native = hasTag(eventParsedComment, "native");
-	const eventDetails = event?.expression?.arguments?.[1]?.properties?.find(prop => prop?.name?.text === "detail")?.initializer?.properties;
-
-	if (event?.expression?.arguments?.[1] && !event?.expression?.typeArguments) {
-		logDocumentationError(moduleDoc.path, `Event details for event '${name}' must be described using generics. Add type via generics to the decorator: @event<TypeForDetails>("${name}", {details}).`)
-	}
+	const eventArgs = event?.expression?.arguments;
+	let eventBubbles;
+	let eventCancelable;
+	let eventDetails;
+
+	eventArgs && eventArgs.forEach(arg => {
+		arg.properties?.forEach(prop => {
+			if (prop.name?.text === "bubbles") {
+				eventBubbles = prop.initializer.kind === ASTFalseKeywordCode ? false : true;
+			} else if (prop.name?.text === "cancelable") {
+				eventCancelable = prop.initializer.kind === ASTFalseKeywordCode ? false : true;
+			} else if (prop.name?.text === "detail") {
+				eventDetails = prop.initializer?.properties;
+			}
+		});
+	});
 
 	result.description = description;
-	result._ui5allowPreventDefault = allowPreventDefault;
+	result._ui5Cancelable = eventCancelable !== undefined ? eventCancelable : false;
+	result._ui5allowPreventDefault = result._ui5Cancelable;
+	result._ui5Bubbles = eventBubbles !== undefined ? eventBubbles : false;
 
 	if (native) {
 		result.type = { text: "Event" };
-	} else if (event?.expression?.typeArguments) {
-		const typesText = event?.expression?.typeArguments.map(type => type.typeName?.text).filter(Boolean).join(" | ");
-		const typeRefs = (getTypeRefs(ts, event.expression)
-			?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
-
-		result.type = { text: `CustomEvent<${typesText}>` };
-
-		if (typeRefs.length) {
-			result.type.references = typeRefs;
-		}
 	}
 
 	if (privacy) {
@@ -121,7 +112,53 @@ function processEvent(ts, event, classNode, moduleDoc) {
 			: sinceTag.name;
 	}
 
-	if (commentParams && eventDetails) {
+	const eventDetailType = classNode.members?.find(member => {
+		return ts.isPropertyDeclaration(member) && member.name.text === "eventDetails"
+	})?.type;
+	const eventDetailRef = eventDetailType?.members?.find(member => member.name.text === name) || eventDetailType?.types?.[eventDetailType?.types?.length - 1]?.members?.find(member => member.name.text === name);
+	const hasGeneric = !!event?.expression?.typeArguments
+
+	if (commentParams.length) {
+		if (eventDetailRef && hasGeneric) {
+			logDocumentationError(moduleDoc.path, `Event details for event '${name}' has to be defined either with generic or with eventDetails.`)
+		} else if (eventDetails) {
+			if (hasGeneric) {
+				const typesText = event?.expression?.typeArguments.map(type => type.typeName?.text).filter(Boolean).join(" | ");
+				const typeRefs = (getTypeRefs(ts, event.expression)
+					?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
+
+				result.type = { text: `CustomEvent<${typesText}>` };
+
+				if (typeRefs.length) {
+					result.type.references = typeRefs;
+				}
+			} else if (eventDetailRef) {
+				const typesText = eventDetailRef?.type?.typeName?.text;
+				const typeRefs = (getTypeRefs(ts, eventDetailRef)
+					?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
+
+				result.type = { text: `CustomEvent<${typesText}>` };
+
+				if (typeRefs.length) {
+					result.type.references = typeRefs;
+				}
+			} else {
+				logDocumentationError(moduleDoc.path, `Event details for event '${name}' must be described using generics. Add type via generics to the decorator: @event<TypeForDetails>("${name}", {details}).`)
+			}
+		} else if (eventDetailRef) {
+			const typesText = eventDetailRef?.type?.typeName?.text;
+			const typeRefs = (getTypeRefs(ts, eventDetailRef)
+				?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
+
+			result.type = { text: `CustomEvent<${typesText}>` };
+
+			if (typeRefs.length) {
+				result.type.references = typeRefs;
+			}
+		} else {
+			logDocumentationError(moduleDoc.path, `Event details for event '${name}' must be described.`)
+		}
+
 		result._ui5parameters = getParams(ts, eventDetails, commentParams, classNode, moduleDoc);
 	}
 

package/lib/cem/merge.mjs

@@ -0,0 +1,220 @@
+import { pathToFileURL } from "url";
+import path from "path";
+import { createRequire } from 'module';
+import { readFile, writeFile } from "fs/promises";
+
+const require = createRequire(import.meta.url);
+
+const UI5_BASE_CLASS = "UI5Element";
+
+const main = async (argv) => {
+    let customElementsPath = null;
+    const CACHED_CEMS = new Map();
+    const DECLARATION_PACKAGE = new WeakMap();
+    const DECLARATION_MODULE = new WeakMap();
+
+    function removeInheritedFrom(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+
+        if (Array.isArray(obj)) {
+            return obj.map(item => removeInheritedFrom(item));
+        }
+
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === 'inheritedFrom') {
+                continue;
+            }
+            result[key] = removeInheritedFrom(value);
+        }
+        return result;
+    }
+
+    async function readPackageJson(filePath) {
+        try {
+            return JSON.parse(await readFile(filePath, "utf-8"));
+        } catch (error) {
+            throw new Error(`Failed to read package.json at ${filePath}: ${error.message}`);
+        }
+    }
+
+    async function loadPackageJson(depName) {
+        try {
+            // First try the standard require method (works when exports includes package.json)
+            const pkg = require(`${depName}/package.json`);
+            const pkgPath = require.resolve(`${depName}/package.json`);
+            return { path: path.dirname(pkgPath), pkg };
+        } catch (e) {
+            // If that fails, resolve the package path and read package.json directly
+            try {
+                const packagePath = require.resolve(depName);
+                let currentDir = path.dirname(packagePath);
+
+                // Navigate up to find package.json (the resolved path might be deep in dist/ or similar)
+                while (currentDir !== path.parse(currentDir).root) {
+                    try {
+                        const pkgPath = path.join(currentDir, 'package.json');
+                        const content = await readFile(pkgPath, 'utf-8');
+                        const pkg = JSON.parse(content);
+
+                        // Verify this is the correct package.json by checking the name
+                        if (pkg.name === depName) {
+                            return { path: currentDir, pkg };
+                        }
+                    } catch {
+                        // Continue searching up the directory tree
+                    }
+                    currentDir = path.dirname(currentDir);
+                }
+            } catch (resolveError) {
+                // console.warn(`Could not resolve ${depName}:`, resolveError.message);
+            }
+            return null;
+        }
+    }
+
+    async function collectThirdPartyCem() {
+        const packageJSONPath = path.resolve(process.cwd(), "package.json");
+        const packageJSON = await readPackageJson(packageJSONPath);
+
+        const dependencyKeys = Object.keys(packageJSON).filter(key => key.toLowerCase().includes("dependencies"));
+        const dependencies = dependencyKeys.flatMap(key => Object.keys(packageJSON[key]));
+
+        const thirdPartCEM = (await Promise.all(dependencies.map(async dep => {
+            const result = await loadPackageJson(dep);
+            if (!result?.pkg?.customElements) return null;
+
+            return {
+                path: result.path,
+                name: dep,
+                cem: result.pkg.customElements
+            };
+        }))).filter(Boolean);
+
+        await Promise.all(thirdPartCEM.map(async dep => {
+            const cemPath = path.resolve(dep.path, dep.cem);
+            try {
+                const cemContent = JSON.parse(await readFile(cemPath, "utf-8"));
+                CACHED_CEMS.set(dep.name, cemContent);
+            } catch (error) {
+                console.warn(`Failed to read CEM for ${dep.name} from ${cemPath}: ${error.message}`);
+            }
+        }));
+    }
+
+    async function readCurrentCEM() {
+        const packageJSONPath = path.resolve(process.cwd(), "package.json");
+        const packageJSON = await readPackageJson(packageJSONPath);
+
+        if (!packageJSON?.customElements) {
+            return null;
+        }
+
+        customElementsPath = packageJSON.customElements;
+        const cemPath = path.resolve(process.cwd(), customElementsPath);
+
+        try {
+            const cemContent = JSON.parse(await readFile(cemPath, "utf-8"));
+            CACHED_CEMS.set(packageJSON.name, cemContent);
+            return cemContent;
+        } catch (error) {
+            throw new Error(`Failed to read CEM from ${cemPath}: ${error.message}`);
+        }
+    }
+
+    async function resolveReference(ref) {
+        const pkg = CACHED_CEMS.get(ref.package);
+
+        if (!pkg) {
+            return null;
+        }
+
+        const mod = (pkg.modules || []).find(m => m.path === ref.module);
+
+        if (!mod) {
+            return null;
+        }
+
+        const declaration = (mod.declarations || []).find(d => d.name === ref.name);
+
+        if (!declaration) {
+            return null;
+        }
+
+        DECLARATION_PACKAGE.set(declaration, ref.package);
+        DECLARATION_MODULE.set(declaration, ref.module);
+
+        return resolveDeclaration(declaration);
+    }
+
+    async function resolveDeclaration(declaration) {
+        if (!declaration.superclass || declaration.superclass.name === UI5_BASE_CLASS) {
+            return [declaration];
+        }
+
+        const superclassDeclarations = await resolveReference(declaration.superclass);
+        return [declaration, superclassDeclarations].flat().filter(Boolean);
+    }
+
+    const merge = async () => {
+        const currentCEM = await readCurrentCEM();
+        if (!currentCEM) {
+            throw new Error("No custom elements manifest found in current project");
+        }
+
+        await collectThirdPartyCem();
+
+        const modules = currentCEM.modules || [];
+
+        for (const mod of modules) {
+            const declarations = (mod.declarations || []).filter(d => d.kind === "class");
+
+            for (const declaration of declarations) {
+                const declarationHierarchy = await resolveDeclaration(declaration);
+                const allKeys = declarationHierarchy.flatMap(dec => Object.keys(dec));
+                const uniqueKeys = [...new Set(allKeys)];
+                const arrayKeys = uniqueKeys
+                    .filter(key => !key.startsWith("_ui5"))
+                    .filter(key => declarationHierarchy.some(dec => Array.isArray(dec[key])));
+
+                for (const key of arrayKeys) {
+                    const allItems = declarationHierarchy.flatMap(dec => dec[key] || []);
+
+                    // Remove duplicates based on name property
+                    const seen = new Set();
+                    declaration[key] = allItems.filter(item => {
+                        if (!item.name) return true;
+                        if (seen.has(item.name)) return false;
+                        seen.add(item.name);
+                        return true;
+                    });
+                }
+            }
+        }
+
+        const cleanedCEM = removeInheritedFrom(currentCEM);
+        const outputPath = path.resolve(process.cwd(), customElementsPath);
+
+        try {
+            await writeFile(outputPath, JSON.stringify(cleanedCEM, null, 2), "utf-8");
+            console.log(`Successfully merged CEM to ${outputPath}`);
+        } catch (error) {
+            throw new Error(`Failed to write merged CEM to ${outputPath}: ${error.message}`);
+        }
+    };
+
+    await merge();
+}
+
+const filePath = process.argv[1];
+const fileUrl = pathToFileURL(filePath).href;
+
+if (import.meta.url === fileUrl) {
+    main(process.argv)
+}
+
+export default {
+    _ui5mainFn: main
+}