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

package/src/locale/normalizeLocale.ts

@@ -0,0 +1,56 @@
+import { DEFAULT_LOCALE } from "../generated/AssetParameters.js";
+
+const localeRegEX = /^((?:[A-Z]{2,3}(?:-[A-Z]{3}){0,3})|[A-Z]{4}|[A-Z]{5,8})(?:-([A-Z]{4}))?(?:-([A-Z]{2}|[0-9]{3}))?((?:-[0-9A-Z]{5,8}|-[0-9][0-9A-Z]{3})*)((?:-[0-9A-WYZ](?:-[0-9A-Z]{2,8})+)*)(?:-(X(?:-[0-9A-Z]{1,8})+))?$/i;
+const SAPSupportabilityLocales = /(?:^|-)(saptrc|sappsd)(?:-|$)/i;
+
+/* Map for old language names for a few ISO639 codes. */
+const M_ISO639_NEW_TO_OLD = {
+	"he": "iw",
+	"yi": "ji",
+	"nb": "no",
+	"sr": "sh",
+};
+
+/**
+ * Normalizes the given locale in BCP-47 syntax.
+ * @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: string) => {
+	let m;
+
+	if (!locale) {
+		return DEFAULT_LOCALE;
+	}
+
+	if (typeof locale === "string" && (m = localeRegEX.exec(locale.replace(/_/g, "-")))) {/* eslint-disable-line */
+		let language = m[1].toLowerCase();
+		let region = m[3] ? m[3].toUpperCase() : undefined;
+		const script = m[2] ? m[2].toLowerCase() : undefined;
+		const variants = m[4] ? m[4].slice(1) : undefined;
+		const isPrivate = m[6];
+
+		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 */ ||
+			(variants && (m = SAPSupportabilityLocales.exec(variants)))) {/* eslint-disable-line */
+			return `en_US_${m[1].toLowerCase()}`; // for now enforce en_US (agreed with SAP SLS)
+		}
+
+		// Chinese: when no region but a script is specified, use default region for each script
+		if (language === "zh" && !region) {
+			if (script === "hans") {
+				region = "CN";
+			} else if (script === "hant") {
+				region = "TW";
+			}
+		}
+
+		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/directives/style-map.js

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * This is the original style-map.js directive from lit-html 2 with the only difference that "render" is not called even for the first rendering (update is used instead)
+ */
+
+import { noChange } from 'lit-html';
+import { directive, Directive, PartType, } from 'lit-html/directive.js';
+class StyleMapDirective extends Directive {
+	constructor(partInfo) {
+		var _a;
+		super(partInfo);
+		if (partInfo.type !== PartType.ATTRIBUTE ||
+			partInfo.name !== 'style' ||
+			((_a = partInfo.strings) === null || _a === void 0 ? void 0 : _a.length) > 2) {
+			throw new Error('The `styleMap` directive must be used in the `style` attribute ' +
+				'and must be the only part in the attribute.');
+		}
+	}
+	render(styleInfo) {
+		return "";
+	}
+	update(part, [styleInfo]) {
+		const { style } = part.element;
+		if (this._previousStyleProperties === undefined) {
+			this._previousStyleProperties = new Set();
+			for (const name in styleInfo) {
+				this._previousStyleProperties.add(name);
+			}
+			// return this.render(styleInfo);
+		}
+		// Remove old properties that no longer exist in styleInfo
+		// We use forEach() instead of for-of so that re don't require down-level
+		// iteration.
+		this._previousStyleProperties.forEach((name) => {
+			// If the name isn't in styleInfo or it's null/undefined
+			if (styleInfo[name] == null) {
+				this._previousStyleProperties.delete(name);
+				if (name.includes('-')) {
+					style.removeProperty(name);
+				}
+				else {
+					// Note reset using empty string (vs null) as IE11 does not always
+					// reset via null (https://developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style#setting_styles)
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					style[name] = '';
+				}
+			}
+		});
+		// Add or update properties
+		for (const name in styleInfo) {
+			const value = styleInfo[name];
+			if (value != null) {
+				this._previousStyleProperties.add(name);
+				if (name.includes('-')) {
+					style.setProperty(name, value);
+				}
+				else {
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					style[name] = value;
+				}
+			}
+		}
+		return noChange;
+	}
+}
+
+export const styleMap = directive(StyleMapDirective);

package/src/renderer/executeTemplate.ts

@@ -0,0 +1,40 @@
+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
+ *
+ * @param template - the template to execute
+ * @param component - the component
+ * @public
+ */
+const executeTemplate = (template: TemplateFunction, component: UI5Element): TemplateFunctionResult => {
+	const tagsToScope = getTagsToScope(component);
+	const scope = getCustomElementsScopingSuffix();
+	return template(component, tagsToScope, scope);
+};
+
+/**
+ * Returns all tags, used inside component's template subject to scoping.
+ * @param component - the component
+ * @returns {Array[]}
+ * @private
+ */
+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);
+	}
+
+	return tagsToScope;
+};
+
+export default executeTemplate;
+export type { TemplateFunction, TemplateFunctionResult };

package/src/theming/CustomStyle.ts

@@ -0,0 +1,64 @@
+import { reRenderAllUI5Elements } from "../Render.js";
+import getSharedResource from "../getSharedResource.js";
+import EventProvider from "../EventProvider.js";
+
+type CustomCSSChangeCallback = (tag: string) => void;
+
+const getEventProvider = () => getSharedResource("CustomStyle.eventProvider", new EventProvider<string, void>());
+const CUSTOM_CSS_CHANGE = "CustomCSSChange";
+
+const attachCustomCSSChange = (listener: CustomCSSChangeCallback) => {
+	getEventProvider().attachEvent(CUSTOM_CSS_CHANGE, listener);
+};
+
+const detachCustomCSSChange = (listener: CustomCSSChangeCallback) => {
+	getEventProvider().detachEvent(CUSTOM_CSS_CHANGE, listener);
+};
+
+const fireCustomCSSChange = (tag: string) => {
+	return getEventProvider().fireEvent(CUSTOM_CSS_CHANGE, tag);
+};
+
+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: boolean;
+attachCustomCSSChange((tag: string) => {
+	if (!skipRerender) {
+		reRenderAllUI5Elements({ tag });
+	}
+});
+
+const addCustomCSS = (tag: string, css: string) => {
+	const customCSSFor = getCustomCSSFor();
+	if (!customCSSFor[tag]) {
+		customCSSFor[tag] = [];
+	}
+	customCSSFor[tag].push(css);
+
+	skipRerender = true;
+	try {
+		// The event is fired and the attached event listeners are all called synchronously
+		// The skipRerender flag will be used to avoid calling reRenderAllUI5Elements twice when it is this copy
+		// of CustomStyle.js which is firing the `CustomCSSChange` event.
+		fireCustomCSSChange(tag);
+	} finally {
+		skipRerender = false;
+	}
+
+	return reRenderAllUI5Elements({ tag });
+};
+
+const getCustomCSS = (tag: string) => {
+	const customCSSFor = getCustomCSSFor();
+	return customCSSFor[tag] ? customCSSFor[tag].join("") : "";
+};
+
+export {
+	addCustomCSS,
+	getCustomCSS,
+	attachCustomCSSChange,
+	detachCustomCSSChange,
+};

package/src/theming/ThemeLoaded.ts

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

package/src/theming/applyTheme.ts

@@ -0,0 +1,90 @@
+import { getThemeProperties, getRegisteredPackages, isThemeRegistered } from "../asset-registries/Themes.js";
+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";
+
+const isThemeBaseRegistered = () => {
+	const registeredPackages = getRegisteredPackages();
+	return registeredPackages.has(BASE_THEME_PACKAGE);
+};
+
+const loadThemeBase = async (theme: string) => {
+	if (!isThemeBaseRegistered()) {
+		return;
+	}
+
+	const cssData = await getThemeProperties(BASE_THEME_PACKAGE, theme);
+	if (cssData) {
+		createOrUpdateStyle(cssData, "data-ui5-theme-properties", BASE_THEME_PACKAGE);
+	}
+};
+
+const deleteThemeBase = () => {
+	removeStyle("data-ui5-theme-properties", BASE_THEME_PACKAGE);
+};
+
+const loadComponentPackages = async (theme: string) => {
+	const registeredPackages = getRegisteredPackages();
+
+	const packagesStylesPromises = [...registeredPackages].map(async packageName => {
+		if (packageName === BASE_THEME_PACKAGE) {
+			return;
+		}
+
+		const cssData = await getThemeProperties(packageName, theme);
+		if (cssData) {
+			createOrUpdateStyle(cssData, "data-ui5-theme-properties", packageName);
+		}
+	});
+
+	return Promise.all(packagesStylesPromises);
+};
+
+const detectExternalTheme = async (theme: string) => {
+	// If theme designer theme is detected, use this
+	const extTheme = getThemeDesignerTheme();
+	if (extTheme) {
+		return extTheme;
+	}
+
+	// If OpenUI5Support is enabled, try to find out if it loaded variables
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
+	if (openUI5Support) {
+		const varsLoaded = openUI5Support.cssVariablesLoaded();
+		if (varsLoaded) {
+			return {
+				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: 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) {
+		await loadThemeBase(theme);
+	} else {
+		deleteThemeBase();
+	}
+
+	// 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 || DEFAULT_THEME);
+
+	fireThemeLoaded(theme);
+};
+
+export default applyTheme;

package/src/theming/getConstructableStyle.ts

@@ -0,0 +1,31 @@
+import getEffectiveStyle from "./getEffectiveStyle.js";
+import { attachCustomCSSChange } from "./CustomStyle.js";
+import UI5Element from "../UI5Element.js";
+
+const constructableStyleMap = new Map<string, Array<CSSStyleSheet>>();
+
+attachCustomCSSChange((tag: string) => {
+	constructableStyleMap.delete(`${tag}_normal`); // there is custom CSS only for the component itself, not for its static area part
+});
+
+/**
+ * Returns (and caches) a constructable style sheet for a web component class
+ * Note: Chrome
+ * @param ElementClass
+ * @returns {*}
+ */
+const getConstructableStyle = (ElementClass: typeof UI5Element, forStaticArea = false) => {
+	const tag = ElementClass.getMetadata().getTag();
+	const key = `${tag}_${forStaticArea ? "static" : "normal"}`;
+
+	if (!constructableStyleMap.has(key)) {
+		const styleContent = getEffectiveStyle(ElementClass, forStaticArea);
+		const style = new CSSStyleSheet();
+		style.replaceSync(styleContent);
+		constructableStyleMap.set(key, [style]);
+	}
+
+	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.ts

@@ -0,0 +1,41 @@
+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<string, string>();
+
+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: typeof UI5Element, forStaticArea = false) => {
+	const tag = ElementClass.getMetadata().getTag();
+	const key = `${tag}_${forStaticArea ? "static" : "normal"}`;
+	const openUI5Enablement = getFeature<typeof OpenUI5Enablement>("OpenUI5Enablement");
+
+	if (!effectiveStyleMap.has(key)) {
+		let effectiveStyle;
+		let busyIndicatorStyles = "";
+
+		if (openUI5Enablement) {
+			busyIndicatorStyles = getStylesString(openUI5Enablement.getBusyIndicatorStyles());
+		}
+
+		if (forStaticArea) {
+			effectiveStyle = getStylesString(ElementClass.staticAreaStyles);
+		} else {
+			const customStyle = getCustomCSS(tag) || "";
+			const builtInStyles = getStylesString(ElementClass.styles);
+			effectiveStyle = `${builtInStyles} ${customStyle}`;
+		}
+
+		effectiveStyle = `${effectiveStyle} ${busyIndicatorStyles}`;
+		effectiveStyleMap.set(key, effectiveStyle);
+	}
+
+	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.ts

@@ -0,0 +1,101 @@
+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
+	let el = document.querySelector(".sapThemeMetaData-Base-baseLib") || document.querySelector(".sapThemeMetaData-UI5-sap-ui-core");
+	if (el) {
+		return getComputedStyle(el).backgroundImage;
+	}
+
+	el = document.createElement("span");
+	(el as HTMLSpanElement).style.display = "none";
+
+	// Try with sapThemeMetaData-Base-baseLib first
+	el.classList.add("sapThemeMetaData-Base-baseLib");
+	document.body.appendChild(el);
+	let metadata = getComputedStyle(el).backgroundImage;
+
+	// Try with sapThemeMetaData-UI5-sap-ui-core only if the previous selector was not found
+	if (metadata === "none") {
+		el.classList.add("sapThemeMetaData-UI5-sap-ui-core");
+		metadata = getComputedStyle(el).backgroundImage;
+	}
+
+	document.body.removeChild(el);
+
+	return metadata;
+};
+
+const parseThemeMetadata = (metadataString: string) => {
+	const params = /\(["']?data:text\/plain;utf-8,(.*?)['"]?\)$/i.exec(metadataString);
+	if (params && params.length >= 2) {
+		let paramsString = params[1];
+		paramsString = paramsString.replace(/\\"/g, `"`);
+		if (paramsString.charAt(0) !== "{" && paramsString.charAt(paramsString.length - 1) !== "}") {
+			try {
+				paramsString = decodeURIComponent(paramsString);
+			} catch (ex) {
+				if (!warnings.has("decode")) {
+					console.warn("Malformed theme metadata string, unable to decodeURIComponent"); // eslint-disable-line
+					warnings.add("decode");
+				}
+				return;
+			}
+		}
+		try {
+			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
+				warnings.add("parse");
+			}
+		}
+	}
+};
+
+const processThemeMetadata = (metadata: ThemeMetadata): ThemeDescriptor | undefined => {
+	let themeName;
+	let baseThemeName;
+
+	try {
+		themeName = metadata.Path.match(/\.([^.]+)\.css_variables$/)![1];
+		baseThemeName = metadata.Extends[0];
+	} catch (ex) {
+		if (!warnings.has("object")) {
+			console.warn("Malformed theme metadata Object", metadata); // eslint-disable-line
+			warnings.add("object");
+		}
+		return;
+	}
+
+	return {
+		themeName,
+		baseThemeName,
+	};
+};
+
+const getThemeDesignerTheme = (): ThemeDescriptor | undefined => {
+	const metadataString = getThemeMetadata();
+	if (!metadataString || metadataString === "none") {
+		return;
+	}
+
+	const metadata = parseThemeMetadata(metadataString);
+
+	if (metadata) {
+		return processThemeMetadata(metadata);
+	}
+};
+
+export default getThemeDesignerTheme;
+export type { ThemeDescriptor };

package/src/theming/preloadLinks.ts

@@ -0,0 +1,24 @@
+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<string>();
+
+const preloadLinks = (ElementClass: typeof UI5Element) => {
+	if (!shouldUseLinks() || !shouldPreloadLinks()) {
+		return;
+	}
+
+	const linksHrefs = getEffectiveLinksHrefs(ElementClass, false) || [];
+	const staticAreaLinksHrefs = getEffectiveLinksHrefs(ElementClass, true) || [];
+
+	[...linksHrefs, ...staticAreaLinksHrefs].forEach(href => {
+		if (!preloaded.has(href)) {
+			createLinkInHead(href, { rel: "preload", as: "style" });
+			preloaded.add(href);
+		}
+	});
+};
+
+export default preloadLinks;