@ui5/webcomponents-base 0.0.0-cf50976ce → 0.0.0-d4d43327a

package/src/locale/{getLocale.js → getLocale.ts}

@@ -1,18 +1,19 @@
 import detectNavigatorLanguage from "../util/detectNavigatorLanguage.js";
 import { getLanguage as getConfigLanguage } from "../config/Language.js";
 import Locale from "./Locale.js";
+import { DEFAULT_LOCALE } from "../generated/AssetParameters.js";
 
-const cache = new Map();
+const cache = new Map<string, Locale>();
 
-const getLocaleInstance = lang => {
+const getLocaleInstance = (lang: string) => {
 	if (!cache.has(lang)) {
 		cache.set(lang, new Locale(lang));
 	}
 
-	return cache.get(lang);
+	return cache.get(lang)!;
 };
 
-const convertToLocaleOrNull = lang => {
+const convertToLocaleOrNull = (lang: string) => {
 	try {
 		if (lang && typeof lang === "string") {
 			return getLocaleInstance(lang);
@@ -20,19 +21,23 @@ const convertToLocaleOrNull = lang => {
 	} catch (e) {
 		// ignore
 	}
+
+	return new Locale(DEFAULT_LOCALE);
 };
 
 /**
  * Returns the locale based on the parameter or configured language Configuration#getLanguage
  * If no language has been configured - a new locale based on browser language is returned
  */
-const getLocale = lang => {
+const getLocale = (lang?: string): Locale => {
 	if (lang) {
 		return convertToLocaleOrNull(lang);
 	}
 
-	if (getConfigLanguage()) {
-		return getLocaleInstance(getConfigLanguage());
+	const configLanguage = getConfigLanguage();
+
+	if (configLanguage) {
+		return getLocaleInstance(configLanguage);
 	}
 
 	return convertToLocaleOrNull(detectNavigatorLanguage());

package/src/locale/languageChange.ts

@@ -0,0 +1,24 @@
+import EventProvider from "../EventProvider.js";
+
+type LanguageChangeCallback = (lang: string) => Promise<void | Array<void>>;
+
+const eventProvider = new EventProvider<string, Promise<void | Array<void>>>();
+const LANG_CHANGE = "languageChange";
+
+const attachLanguageChange = (listener: LanguageChangeCallback) => {
+	eventProvider.attachEvent(LANG_CHANGE, listener);
+};
+
+const detachLanguageChange = (listener: LanguageChangeCallback) => {
+	eventProvider.detachEvent(LANG_CHANGE, listener);
+};
+
+const fireLanguageChange = (lang: string) => {
+	return eventProvider.fireEventAsync(LANG_CHANGE, lang);
+};
+
+export {
+	attachLanguageChange,
+	detachLanguageChange,
+	fireLanguageChange,
+};

package/src/locale/{nextFallbackLocale.js → nextFallbackLocale.ts}

@@ -6,7 +6,7 @@ import { DEFAULT_LOCALE } from "../generated/AssetParameters.js";
  * @param {string} locale Locale string in Java format (underscores) or null
  * @returns {string} Next fallback Locale or "en" if no fallbacks found.
  */
-const nextFallbackLocale = locale => {
+const nextFallbackLocale = (locale: string) => {
 	if (!locale) {
 		return DEFAULT_LOCALE;
 	}

package/src/locale/{normalizeLocale.js → normalizeLocale.ts}

@@ -7,7 +7,7 @@ const SAPSupportabilityLocales = /(?:^|-)(saptrc|sappsd)(?:-|$)/i;
 const M_ISO639_NEW_TO_OLD = {
 	"he": "iw",
 	"yi": "ji",
-	"id": "in",
+	"nb": "no",
 	"sr": "sh",
 };
 
@@ -16,7 +16,7 @@ const M_ISO639_NEW_TO_OLD = {
  * @param {string} locale locale to normalize
  * @returns {string} Normalized locale, "undefined" if the locale can't be normalized or the default locale, if no locale provided.
  */
-const normalizeLocale = locale => {
+const normalizeLocale = (locale: string) => {
 	let m;
 
 	if (!locale) {
@@ -30,7 +30,7 @@ const normalizeLocale = locale => {
 		const variants = m[4] ? m[4].slice(1) : undefined;
 		const isPrivate = m[6];
 
-		language = M_ISO639_NEW_TO_OLD[language] || language;
+		language = M_ISO639_NEW_TO_OLD[language as keyof typeof M_ISO639_NEW_TO_OLD] || language;
 
 		// recognize and convert special SAP supportability locales (overwrites m[]!)
 		if ((isPrivate && (m = SAPSupportabilityLocales.exec(isPrivate))) /* eslint-disable-line */ ||
@@ -49,6 +49,8 @@ const normalizeLocale = locale => {
 
 		return language + (region ? "_" + region + (variants ? "_" + variants.replace("-", "_") : "") : ""); /* eslint-disable-line */
 	}
+
+	return DEFAULT_LOCALE;
 };
 
 export default normalizeLocale;

package/src/renderer/LitRenderer.ts

@@ -0,0 +1,60 @@
+import {
+	render,
+	html,
+	svg,
+	TemplateResult,
+} from "lit-html";
+
+import { getFeature } from "../FeaturesRegistry.js";
+import type { LitStatic } from "../CustomElementsScope.js";
+import type OpenUI5Enablement from "../features/OpenUI5Enablement.js";
+import type UI5Element from "../UI5Element.js";
+import type { Renderer, RendererOptions } from "../UI5Element.js";
+import { TemplateFunctionResult } from "./executeTemplate.js";
+
+const effectiveHtml = (strings: TemplateStringsArray, ...values: Array<unknown>) => {
+	const litStatic = getFeature<typeof LitStatic>("LitStatic");
+	const fn = litStatic ? litStatic.html : html;
+	return fn(strings, ...values);
+};
+
+const effectiveSvg = (strings: TemplateStringsArray, ...values: Array<unknown>) => {
+	const litStatic = getFeature<typeof LitStatic>("LitStatic");
+	const fn = litStatic ? litStatic.svg : svg;
+	return fn(strings, ...values);
+};
+
+const litRender: Renderer = (templateResult: TemplateFunctionResult, container: HTMLElement | DocumentFragment, styleStrOrHrefsArr: string | Array<string> | undefined, forStaticArea: boolean, options: RendererOptions) => {
+	const openUI5Enablement = getFeature<typeof OpenUI5Enablement>("OpenUI5Enablement");
+	if (openUI5Enablement && !forStaticArea) {
+		templateResult = openUI5Enablement.wrapTemplateResultInBusyMarkup(effectiveHtml, options.host as UI5Element, templateResult as TemplateResult);
+	}
+
+	if (typeof styleStrOrHrefsArr === "string") {
+		templateResult = effectiveHtml`<style>${styleStrOrHrefsArr}</style>${templateResult}`;
+	} else if (Array.isArray(styleStrOrHrefsArr) && styleStrOrHrefsArr.length) {
+		templateResult = effectiveHtml`${styleStrOrHrefsArr.map(href => effectiveHtml`<link type="text/css" rel="stylesheet" href="${href}">`)}${templateResult}`;
+	}
+	render(templateResult as TemplateResult, container, options);
+};
+
+const scopeTag = (tag: string, tags: Array<string>, suffix: string) => {
+	const litStatic = getFeature<typeof LitStatic>("LitStatic");
+	if (litStatic) {
+		return litStatic.unsafeStatic((tags || []).includes(tag) ? `${tag}-${suffix}` : tag);
+	}
+};
+
+export {
+	effectiveHtml as html,
+	effectiveSvg as svg,
+};
+export { scopeTag };
+export { repeat } from "lit-html/directives/repeat.js";
+export { classMap } from "lit-html/directives/class-map.js";
+// @ts-ignore style-map is a JS file
+export { styleMap } from "./directives/style-map.js";
+export { ifDefined } from "lit-html/directives/if-defined.js";
+export { unsafeHTML } from "lit-html/directives/unsafe-html.js";
+
+export default litRender;

package/src/renderer/{executeTemplate.js → executeTemplate.ts}

@@ -1,4 +1,8 @@
 import { getCustomElementsScopingSuffix, shouldScopeCustomElement } from "../CustomElementsScopeUtils.js";
+import type UI5Element from "../UI5Element.js";
+
+type TemplateFunctionResult = object;
+type TemplateFunction = (component: UI5Element, tagsToScope: Array<string>, scope: string | undefined) => TemplateFunctionResult;
 
 /**
  * Runs a component's template with the component's current state, while also scoping HTML
@@ -6,9 +10,8 @@ import { getCustomElementsScopingSuffix, shouldScopeCustomElement } from "../Cus
  * @param template - the template to execute
  * @param component - the component
  * @public
- * @returns {*}
  */
-const executeTemplate = (template, component) => {
+const executeTemplate = (template: TemplateFunction, component: UI5Element): TemplateFunctionResult => {
 	const tagsToScope = getTagsToScope(component);
 	const scope = getCustomElementsScopingSuffix();
 	return template(component, tagsToScope, scope);
@@ -20,9 +23,11 @@ const executeTemplate = (template, component) => {
  * @returns {Array[]}
  * @private
  */
-const getTagsToScope = component => {
-	const componentTag = component.constructor.getMetadata().getPureTag();
-	const tagsToScope = component.constructor.getUniqueDependencies().map(dep => dep.getMetadata().getPureTag()).filter(shouldScopeCustomElement);
+const getTagsToScope = (component: UI5Element) => {
+	const ctor = component.constructor as typeof UI5Element;
+
+	const componentTag = ctor.getMetadata().getPureTag();
+	const tagsToScope = ctor.getUniqueDependencies().map((dep: typeof UI5Element) => dep.getMetadata().getPureTag()).filter(shouldScopeCustomElement);
 
 	if (shouldScopeCustomElement(componentTag)) {
 		tagsToScope.push(componentTag);
@@ -32,3 +37,4 @@ const getTagsToScope = component => {
 };
 
 export default executeTemplate;
+export type { TemplateFunction, TemplateFunctionResult };

package/src/theming/{CustomStyle.js → CustomStyle.ts}

@@ -2,34 +2,37 @@ import { reRenderAllUI5Elements } from "../Render.js";
 import getSharedResource from "../getSharedResource.js";
 import EventProvider from "../EventProvider.js";
 
-const eventProvider = getSharedResource("CustomStyle.eventProvider", new EventProvider());
+type CustomCSSChangeCallback = (tag: string) => void;
+
+const getEventProvider = () => getSharedResource("CustomStyle.eventProvider", new EventProvider<string, void>());
 const CUSTOM_CSS_CHANGE = "CustomCSSChange";
 
-const attachCustomCSSChange = listener => {
-	eventProvider.attachEvent(CUSTOM_CSS_CHANGE, listener);
+const attachCustomCSSChange = (listener: CustomCSSChangeCallback) => {
+	getEventProvider().attachEvent(CUSTOM_CSS_CHANGE, listener);
 };
 
-const detachCustomCSSChange = listener => {
-	eventProvider.detachEvent(CUSTOM_CSS_CHANGE, listener);
+const detachCustomCSSChange = (listener: CustomCSSChangeCallback) => {
+	getEventProvider().detachEvent(CUSTOM_CSS_CHANGE, listener);
 };
 
-const fireCustomCSSChange = tag => {
-	return eventProvider.fireEvent(CUSTOM_CSS_CHANGE, tag);
+const fireCustomCSSChange = (tag: string) => {
+	return getEventProvider().fireEvent(CUSTOM_CSS_CHANGE, tag);
 };
 
-const customCSSFor = getSharedResource("CustomStyle.customCSSFor", {});
+const getCustomCSSFor = () => getSharedResource<Record<string, Array<string>>>("CustomStyle.customCSSFor", {});
 
 // Listen to the eventProvider, in case other copies of this CustomStyle module fire this
 // event, and this copy would therefore need to reRender the ui5 webcomponents; but
 // don't reRender if it was this copy that fired the event to begin with.
-let skipRerender;
-attachCustomCSSChange(tag => {
+let skipRerender: boolean;
+attachCustomCSSChange((tag: string) => {
 	if (!skipRerender) {
 		reRenderAllUI5Elements({ tag });
 	}
 });
 
-const addCustomCSS = (tag, css) => {
+const addCustomCSS = (tag: string, css: string) => {
+	const customCSSFor = getCustomCSSFor();
 	if (!customCSSFor[tag]) {
 		customCSSFor[tag] = [];
 	}
@@ -48,7 +51,8 @@ const addCustomCSS = (tag, css) => {
 	return reRenderAllUI5Elements({ tag });
 };
 
-const getCustomCSS = tag => {
+const getCustomCSS = (tag: string) => {
+	const customCSSFor = getCustomCSSFor();
 	return customCSSFor[tag] ? customCSSFor[tag].join("") : "";
 };
 

package/src/theming/{ThemeLoaded.js → ThemeLoaded.ts}

@@ -1,17 +1,19 @@
 import EventProvider from "../EventProvider.js";
 
-const eventProvider = new EventProvider();
+type ThemeLoadedCallback = (theme: string) => void;
+
+const eventProvider = new EventProvider<string, void>();
 const THEME_LOADED = "themeLoaded";
 
-const attachThemeLoaded = listener => {
+const attachThemeLoaded = (listener: ThemeLoadedCallback) => {
 	eventProvider.attachEvent(THEME_LOADED, listener);
 };
 
-const detachThemeLoaded = listener => {
+const detachThemeLoaded = (listener: ThemeLoadedCallback) => {
 	eventProvider.detachEvent(THEME_LOADED, listener);
 };
 
-const fireThemeLoaded = theme => {
+const fireThemeLoaded = (theme: string) => {
 	return eventProvider.fireEvent(THEME_LOADED, theme);
 };
 

package/src/theming/{applyTheme.js → applyTheme.ts}

@@ -3,6 +3,9 @@ import { removeStyle, createOrUpdateStyle } from "../ManagedStyles.js";
 import getThemeDesignerTheme from "./getThemeDesignerTheme.js";
 import { fireThemeLoaded } from "./ThemeLoaded.js";
 import { getFeature } from "../FeaturesRegistry.js";
+import { attachCustomThemeStylesToHead, getThemeRoot } from "../config/ThemeRoots.js";
+import type OpenUI5Support from "../features/OpenUI5Support.js";
+import { DEFAULT_THEME } from "../generated/AssetParameters.js";
 
 const BASE_THEME_PACKAGE = "@ui5/webcomponents-theming";
 
@@ -11,7 +14,7 @@ const isThemeBaseRegistered = () => {
 	return registeredPackages.has(BASE_THEME_PACKAGE);
 };
 
-const loadThemeBase = async theme => {
+const loadThemeBase = async (theme: string) => {
 	if (!isThemeBaseRegistered()) {
 		return;
 	}
@@ -26,9 +29,10 @@ const deleteThemeBase = () => {
 	removeStyle("data-ui5-theme-properties", BASE_THEME_PACKAGE);
 };
 
-const loadComponentPackages = async theme => {
+const loadComponentPackages = async (theme: string) => {
 	const registeredPackages = getRegisteredPackages();
-	registeredPackages.forEach(async packageName => {
+
+	const packagesStylesPromises = [...registeredPackages].map(async packageName => {
 		if (packageName === BASE_THEME_PACKAGE) {
 			return;
 		}
@@ -38,9 +42,11 @@ const loadComponentPackages = async theme => {
 			createOrUpdateStyle(cssData, "data-ui5-theme-properties", packageName);
 		}
 	});
+
+	return Promise.all(packagesStylesPromises);
 };
 
-const detectExternalTheme = () => {
+const detectExternalTheme = async (theme: string) => {
 	// If theme designer theme is detected, use this
 	const extTheme = getThemeDesignerTheme();
 	if (extTheme) {
@@ -48,19 +54,24 @@ const detectExternalTheme = () => {
 	}
 
 	// If OpenUI5Support is enabled, try to find out if it loaded variables
-	const OpenUI5Support = getFeature("OpenUI5Support");
-	if (OpenUI5Support) {
-		const varsLoaded = OpenUI5Support.cssVariablesLoaded();
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
+	if (openUI5Support) {
+		const varsLoaded = openUI5Support.cssVariablesLoaded();
 		if (varsLoaded) {
 			return {
-				themeName: OpenUI5Support.getConfigurationSettingsObject().theme, // just themeName, baseThemeName is only relevant for custom themes
+				themeName: openUI5Support.getConfigurationSettingsObject()?.theme, // just themeName
+				baseThemeName: "", // baseThemeName is only relevant for custom themes
 			};
 		}
+	} else if (getThemeRoot()) {
+		await attachCustomThemeStylesToHead(theme);
+
+		return getThemeDesignerTheme();
 	}
 };
 
-const applyTheme = async theme => {
-	const extTheme = detectExternalTheme();
+const applyTheme = async (theme: string) => {
+	const extTheme = await detectExternalTheme(theme);
 
 	// Only load theme_base properties if there is no externally loaded theme, or there is, but it is not being loaded
 	if (!extTheme || theme !== extTheme.themeName) {
@@ -71,7 +82,7 @@ const applyTheme = async theme => {
 
 	// Always load component packages properties. For non-registered themes, try with the base theme, if any
 	const packagesTheme = isThemeRegistered(theme) ? theme : extTheme && extTheme.baseThemeName;
-	await loadComponentPackages(packagesTheme);
+	await loadComponentPackages(packagesTheme || DEFAULT_THEME);
 
 	fireThemeLoaded(theme);
 };

package/src/theming/{getConstructableStyle.js → getConstructableStyle.ts}

@@ -1,9 +1,10 @@
 import getEffectiveStyle from "./getEffectiveStyle.js";
 import { attachCustomCSSChange } from "./CustomStyle.js";
+import UI5Element from "../UI5Element.js";
 
-const constructableStyleMap = new Map();
+const constructableStyleMap = new Map<string, Array<CSSStyleSheet>>();
 
-attachCustomCSSChange(tag => {
+attachCustomCSSChange((tag: string) => {
 	constructableStyleMap.delete(`${tag}_normal`); // there is custom CSS only for the component itself, not for its static area part
 });
 
@@ -13,7 +14,7 @@ attachCustomCSSChange(tag => {
  * @param ElementClass
  * @returns {*}
  */
-const getConstructableStyle = (ElementClass, forStaticArea = false) => {
+const getConstructableStyle = (ElementClass: typeof UI5Element, forStaticArea = false) => {
 	const tag = ElementClass.getMetadata().getTag();
 	const key = `${tag}_${forStaticArea ? "static" : "normal"}`;
 
@@ -24,7 +25,7 @@ const getConstructableStyle = (ElementClass, forStaticArea = false) => {
 		constructableStyleMap.set(key, [style]);
 	}
 
-	return constructableStyleMap.get(key);
+	return constructableStyleMap.get(key)!;
 };
 
 export default getConstructableStyle;

package/src/theming/getEffectiveLinksHrefs.ts

@@ -0,0 +1,26 @@
+import { getUrl } from "../CSP.js";
+import { getFeature } from "../FeaturesRegistry.js";
+import type UI5Element from "../UI5Element.js";
+import type OpenUI5Enablement from "../features/OpenUI5Enablement.js";
+import type { ComponentStylesData, StyleDataCSP } from "../types.js";
+
+const MAX_DEPTH_INHERITED_CLASSES = 10; // TypeScript complains about Infinity and big numbers
+
+const getEffectiveLinksHrefs = (ElementClass: typeof UI5Element, forStaticArea = false) => {
+	const stylesData: ComponentStylesData = ElementClass[forStaticArea ? "staticAreaStyles" : "styles"];
+
+	if (!stylesData) {
+		return;
+	}
+
+	const stylesDataArray: ComponentStylesData = Array.isArray(stylesData) ? stylesData : [stylesData];
+
+	const openUI5Enablement = getFeature<typeof OpenUI5Enablement>("OpenUI5Enablement");
+	if (openUI5Enablement) {
+		stylesDataArray.push(openUI5Enablement.getBusyIndicatorStyles());
+	}
+
+	return stylesDataArray.flat(MAX_DEPTH_INHERITED_CLASSES).filter(data => !!data).map(data => getUrl((data as StyleDataCSP).packageName, (data as StyleDataCSP).fileName));
+};
+
+export default getEffectiveLinksHrefs;

package/src/theming/{getEffectiveStyle.js → getEffectiveStyle.ts}

@@ -1,24 +1,26 @@
 import { getCustomCSS, attachCustomCSSChange } from "./CustomStyle.js";
 import getStylesString from "./getStylesString.js";
 import { getFeature } from "../FeaturesRegistry.js";
+import type UI5Element from "../UI5Element.js";
+import OpenUI5Enablement from "../features/OpenUI5Enablement.js";
 
-const effectiveStyleMap = new Map();
+const effectiveStyleMap = new Map<string, string>();
 
-attachCustomCSSChange(tag => {
+attachCustomCSSChange((tag: string) => {
 	effectiveStyleMap.delete(`${tag}_normal`); // there is custom CSS only for the component itself, not for its static area part
 });
 
-const getEffectiveStyle = (ElementClass, forStaticArea = false) => {
+const getEffectiveStyle = (ElementClass: typeof UI5Element, forStaticArea = false) => {
 	const tag = ElementClass.getMetadata().getTag();
 	const key = `${tag}_${forStaticArea ? "static" : "normal"}`;
-	const OpenUI5Enablement = getFeature("OpenUI5Enablement");
+	const openUI5Enablement = getFeature<typeof OpenUI5Enablement>("OpenUI5Enablement");
 
 	if (!effectiveStyleMap.has(key)) {
 		let effectiveStyle;
 		let busyIndicatorStyles = "";
 
-		if (OpenUI5Enablement) {
-			busyIndicatorStyles = getStylesString(OpenUI5Enablement.getBusyIndicatorStyles());
+		if (openUI5Enablement) {
+			busyIndicatorStyles = getStylesString(openUI5Enablement.getBusyIndicatorStyles());
 		}
 
 		if (forStaticArea) {
@@ -33,7 +35,7 @@ const getEffectiveStyle = (ElementClass, forStaticArea = false) => {
 		effectiveStyleMap.set(key, effectiveStyle);
 	}
 
-	return effectiveStyleMap.get(key);
+	return effectiveStyleMap.get(key)!; // The key is guaranteed to exist
 };
 
 export default getEffectiveStyle;

package/src/theming/getStylesString.ts

@@ -0,0 +1,15 @@
+import type { ComponentStylesData, StyleData } from "../types.js";
+
+const MAX_DEPTH_INHERITED_CLASSES = 10; // TypeScript complains about Infinity and big numbers
+
+const getStylesString = (styles: ComponentStylesData) => {
+	if (Array.isArray(styles)) {
+		return (styles.filter(style => !!style).flat(MAX_DEPTH_INHERITED_CLASSES) as Array<StyleData>).map((style: StyleData) => {
+			return typeof style === "string" ? style : style.content;
+		}).join(" ");
+	}
+
+	return typeof styles === "string" ? styles : styles.content;
+};
+
+export default getStylesString;

package/src/theming/{getThemeDesignerTheme.js → getThemeDesignerTheme.ts}

@@ -1,4 +1,14 @@
-const warnings = new Set();
+type ThemeDescriptor = {
+	themeName: string,
+	baseThemeName?: string,
+};
+
+type ThemeMetadata = {
+	Path: string,
+	Extends: Array<string>,
+};
+
+const warnings = new Set<string>();
 
 const getThemeMetadata = () => {
 	// Check if the class was already applied, most commonly to the link/style tag with the CSS Variables
@@ -8,7 +18,7 @@ const getThemeMetadata = () => {
 	}
 
 	el = document.createElement("span");
-	el.style.display = "none";
+	(el as HTMLSpanElement).style.display = "none";
 
 	// Try with sapThemeMetaData-Base-baseLib first
 	el.classList.add("sapThemeMetaData-Base-baseLib");
@@ -26,7 +36,7 @@ const getThemeMetadata = () => {
 	return metadata;
 };
 
-const parseThemeMetadata = metadataString => {
+const parseThemeMetadata = (metadataString: string) => {
 	const params = /\(["']?data:text\/plain;utf-8,(.*?)['"]?\)$/i.exec(metadataString);
 	if (params && params.length >= 2) {
 		let paramsString = params[1];
@@ -43,7 +53,7 @@ const parseThemeMetadata = metadataString => {
 			}
 		}
 		try {
-			return JSON.parse(paramsString);
+			return JSON.parse(paramsString) as ThemeMetadata;
 		} catch (ex) {
 			if (!warnings.has("parse")) {
 				console.warn("Malformed theme metadata string, unable to parse JSON"); // eslint-disable-line
@@ -53,12 +63,12 @@ const parseThemeMetadata = metadataString => {
 	}
 };
 
-const processThemeMetadata = metadata => {
+const processThemeMetadata = (metadata: ThemeMetadata): ThemeDescriptor | undefined => {
 	let themeName;
 	let baseThemeName;
 
 	try {
-		themeName = metadata.Path.match(/\.([^.]+)\.css_variables$/)[1];
+		themeName = metadata.Path.match(/\.([^.]+)\.css_variables$/)![1];
 		baseThemeName = metadata.Extends[0];
 	} catch (ex) {
 		if (!warnings.has("object")) {
@@ -74,14 +84,18 @@ const processThemeMetadata = metadata => {
 	};
 };
 
-const getThemeDesignerTheme = () => {
+const getThemeDesignerTheme = (): ThemeDescriptor | undefined => {
 	const metadataString = getThemeMetadata();
 	if (!metadataString || metadataString === "none") {
 		return;
 	}
 
 	const metadata = parseThemeMetadata(metadataString);
-	return processThemeMetadata(metadata);
+
+	if (metadata) {
+		return processThemeMetadata(metadata);
+	}
 };
 
 export default getThemeDesignerTheme;
+export type { ThemeDescriptor };

package/src/theming/{preloadLinks.js → preloadLinks.ts}

@@ -1,10 +1,11 @@
 import getEffectiveLinksHrefs from "./getEffectiveLinksHrefs.js";
 import createLinkInHead from "../util/createLinkInHead.js";
 import { shouldUseLinks, shouldPreloadLinks } from "../CSP.js";
+import type UI5Element from "../UI5Element.js";
 
-const preloaded = new Set();
+const preloaded = new Set<string>();
 
-const preloadLinks = ElementClass => {
+const preloadLinks = (ElementClass: typeof UI5Element) => {
 	if (!shouldUseLinks() || !shouldPreloadLinks()) {
 		return;
 	}

package/src/thirdparty/{_merge.js → _merge.ts}

@@ -1,6 +1,6 @@
 import isPlainObject from './isPlainObject.js';
 var oToken = Object.create(null);
-var fnMerge = function () {
+var fnMerge = function (arg1?: any, arg2?: any, arg3?: any, arg4?: any) {
     var src, copyIsArray, copy, name, options, clone, target = arguments[2] || {}, i = 3, length = arguments.length, deep = arguments[0] || false, skipToken = arguments[1] ? undefined : oToken;
     if (typeof target !== 'object' && typeof target !== 'function') {
         target = {};
@@ -29,4 +29,4 @@ var fnMerge = function () {
     }
     return target;
 };
-export default fnMerge;
+export default fnMerge;

package/src/thirdparty/{isPlainObject.js → isPlainObject.ts}

@@ -3,7 +3,7 @@ var hasOwn = class2type.hasOwnProperty;
 var toString = class2type.toString;
 var fnToString = hasOwn.toString;
 var ObjectFunctionString = fnToString.call(Object);
-var fnIsPlainObject = function (obj) {
+var fnIsPlainObject = function (obj: object) {
   var proto, Ctor;
   if (!obj || toString.call(obj) !== "[object Object]") {
     return false;

package/src/thirdparty/merge.ts

@@ -0,0 +1,5 @@
+import _merge from './_merge.js';
+const fnMerge = function (arg1?: any, arg2?: any) {
+    return _merge(true, false, ...arguments);
+};
+export default fnMerge;

package/src/types/AnimationMode.ts

@@ -0,0 +1,33 @@
+/**
+ * Different types of AnimationMode.
+ *
+ * @class
+ * @enum {string}
+ * @public
+ * @author SAP SE
+ * @alias sap.ui.webc.base.types.AnimationMode
+ */
+enum AnimationMode {
+	/**
+	 * @public
+	 * @type {Full}
+	 */
+	Full = "full",
+	/**
+	 * @public
+	 * @type {Basic}
+	 */
+	Basic = "basic",
+	/**
+	 * @public
+	 * @type {Minimal}
+	 */
+	Minimal = "minimal",
+	/**
+	 * @public
+	 * @type {None}
+	 */
+	None = "none",
+}
+
+export default AnimationMode;