@ui5/webcomponents-base 0.0.0-0742854fd → 0.0.0-11d529e8a

package/dist/EventProvider.js

@@ -1,42 +1,42 @@
 class EventProvider {
 	constructor() {
-		this._eventRegistry = {};
+		this._eventRegistry = new Map();
 	}
 
 	attachEvent(eventName, fnFunction) {
 		const eventRegistry = this._eventRegistry;
-		let eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!Array.isArray(eventListeners)) {
-			eventRegistry[eventName] = [];
-			eventListeners = eventRegistry[eventName];
+			eventRegistry.set(eventName, [fnFunction]);
+			return;
 		}
 
-		eventListeners.push({
-			"function": fnFunction,
-		});
+		if (!eventListeners.includes(fnFunction)) {
+			eventListeners.push(fnFunction);
+		}
 	}
 
 	detachEvent(eventName, fnFunction) {
 		const eventRegistry = this._eventRegistry;
-		let eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!eventListeners) {
 			return;
 		}
+		const indexOfFnToDetach = eventListeners.indexOf(fnFunction);
 
-		eventListeners = eventListeners.filter(event => {
-			return event["function"] !== fnFunction; // eslint-disable-line
-		});
+		if (indexOfFnToDetach !== -1) {
+			eventListeners.splice(indexOfFnToDetach, 1);
+		}
 
 		if (eventListeners.length === 0) {
-			delete eventRegistry[eventName];
+			eventRegistry.delete(eventName);
 		}
 	}
 
 	/**
 	 * Fires an event and returns the results of all event listeners as an array.
-	 * Example: If listeners return promises, you can: await fireEvent("myEvent") to know when all listeners have finished.
 	 *
 	 * @param eventName the event to fire
 	 * @param data optional data to pass to each event listener
@@ -44,37 +44,41 @@ class EventProvider {
 	 */
 	fireEvent(eventName, data) {
 		const eventRegistry = this._eventRegistry;
-		const eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!eventListeners) {
 			return [];
 		}
 
-		return eventListeners.map(event => {
-			return event["function"].call(this, data); // eslint-disable-line
+		return eventListeners.map(fn => {
+			return fn.call(this, data); // eslint-disable-line
 		});
 	}
 
+	/**
+	 * Fires an event and returns a promise that will resolve once all listeners have resolved.
+	 *
+	 * @param eventName the event to fire
+	 * @param data optional data to pass to each event listener
+	 * @returns {Promise} a promise that will resolve when all listeners have resolved
+	 */
+	fireEventAsync(eventName, data) {
+		return Promise.all(this.fireEvent(eventName, data));
+	}
+
 	isHandlerAttached(eventName, fnFunction) {
 		const eventRegistry = this._eventRegistry;
-		const eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!eventListeners) {
 			return false;
 		}
 
-		for (let i = 0; i < eventListeners.length; i++) {
-			const event = eventListeners[i];
-			if (event["function"] === fnFunction) { // eslint-disable-line
-				return true;
-			}
-		}
-
-		return false;
+		return eventListeners.includes(fnFunction);
 	}
 
 	hasListeners(eventName) {
-		return !!this._eventRegistry[eventName];
+		return !!this._eventRegistry.get(eventName);
 	}
 }
 

package/dist/FontFace.js

@@ -56,18 +56,63 @@ const fontFaceCSS = `
 	}
 `;
 
-const insertFontFace = () => {
-	if (document.querySelector(`head>style[data-ui5-font-face]`)) {
-		return;
+/**
+ * Some diacritics are supported by the 72 font:
+ *  * Grave
+ *  * Acute
+ *  * Circumflex
+ *  * Tilde
+ *
+ * However, the following diacritics and the combination of multiple diacritics (including the supported ones) are not supported:
+ *  * Breve
+ *  * Horn
+ *  * Dot below
+ *  * Hook above
+ *
+ *
+ * Override for the characters that aren't covered by the '72' font to other system fonts
+ *
+ * U+0102-0103: A and a with Breve
+ * U+01A0-01A1: O and o with Horn
+ * U+01AF-01B0: U and u with Horn
+ * U+1EA0-1EB7: A and a with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EB8-1EC7: E and e with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EC8-1ECB: I and i with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1ECC-1EE3: O and o with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EE4-1EF1: U and u with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EF4-1EF7: Y and y with diacritics that are not supported by the font and combination of multiple diacritics
+ *
+ */
+const overrideFontFaceCSS = `
+	@font-face {
+		font-family: '72override';
+		unicode-range: U+0102-0103, U+01A0-01A1, U+01AF-01B0, U+1EA0-1EB7, U+1EB8-1EC7, U+1EC8-1ECB, U+1ECC-1EE3, U+1EE4-1EF1, U+1EF4-1EF7;
+		src: local('Arial'), local('Helvetica'), local('sans-serif');
 	}
+`;
 
-	// If OpenUI5 is found, let it set the font
+const insertFontFace = () => {
 	const OpenUI5Support = getFeature("OpenUI5Support");
-	if (OpenUI5Support && OpenUI5Support.isLoaded()) {
-		return;
+
+	// Only set the main font if there is no OpenUI5 support, or there is, but OpenUI5 is not loaded
+	if (!OpenUI5Support || !OpenUI5Support.isLoaded()) {
+		insertMainFontFace();
 	}
 
-	createStyleInHead(fontFaceCSS, { "data-ui5-font-face": "" });
+	// Always set the override font - OpenUI5 in CSS Vars mode does not set it, unlike the main font
+	insertOverrideFontFace();
+};
+
+const insertMainFontFace = () => {
+	if (!document.querySelector(`head>style[data-ui5-font-face]`)) {
+		createStyleInHead(fontFaceCSS, { "data-ui5-font-face": "" });
+	}
+};
+
+const insertOverrideFontFace = () => {
+	if (!document.querySelector(`head>style[data-ui5-font-face-override]`)) {
+		createStyleInHead(overrideFontFaceCSS, { "data-ui5-font-face-override": "" });
+	}
 };
 
 export default insertFontFace;

package/dist/InitialConfiguration.js

@@ -12,8 +12,7 @@ let initialConfig = {
 	calendarType: null,
 	noConflict: false, // no URL
 	formatSettings: {},
-	useDefaultLanguage: false,
-	assetsPath: "",
+	fetchDefaultLanguage: false,
 };
 
 /* General settings */
@@ -38,13 +37,13 @@ const getLanguage = () => {
 };
 
 /**
- * Returns if the default language, that is inlined build time,
- * should be used, instead of trying fetching the language over the network.
+ * Returns if the default language, that is inlined at build time,
+ * should be fetched over the network instead.
  * @returns {Boolean}
  */
-const getUseDefaultLanguage = () => {
+const getFetchDefaultLanguage = () => {
 	initConfiguration();
-	return initialConfig.useDefaultLanguage;
+	return initialConfig.fetchDefaultLanguage;
 };
 
 const getNoConflict = () => {
@@ -62,11 +61,6 @@ const getFormatSettings = () => {
 	return initialConfig.formatSettings;
 };
 
-const getAssetsPath = () => {
-	initConfiguration();
-	return initialConfig.assetsPath;
-};
-
 const booleanMapping = new Map();
 booleanMapping.set("true", true);
 booleanMapping.set("false", false);
@@ -92,23 +86,36 @@ const parseConfigurationScript = () => {
 const parseURLParameters = () => {
 	const params = new URLSearchParams(window.location.search);
 
+	// Process "sap-*" params first
 	params.forEach((value, key) => {
-		if (!key.startsWith("sap-ui")) {
+		const parts = key.split("sap-").length;
+		if (parts === 0 || parts === key.split("sap-ui-").length) {
 			return;
 		}
 
-		const lowerCaseValue = value.toLowerCase();
-
-		const param = key.split("sap-ui-")[1];
+		applyURLParam(key, value, "sap");
+	});
 
-		if (booleanMapping.has(value)) {
-			value = booleanMapping.get(lowerCaseValue);
+	// Process "sap-ui-*" params
+	params.forEach((value, key) => {
+		if (!key.startsWith("sap-ui")) {
+			return;
 		}
 
-		initialConfig[param] = value;
+		applyURLParam(key, value, "sap-ui");
 	});
 };
 
+const applyURLParam = (key, value, paramType) => {
+	const lowerCaseValue = value.toLowerCase();
+	const param = key.split(`${paramType}-`)[1];
+
+	if (booleanMapping.has(value)) {
+		value = booleanMapping.get(lowerCaseValue);
+	}
+	initialConfig[param] = value;
+};
+
 const applyOpenUI5Configuration = () => {
 	const OpenUI5Support = getFeature("OpenUI5Support");
 	if (!OpenUI5Support || !OpenUI5Support.isLoaded()) {
@@ -119,7 +126,6 @@ const applyOpenUI5Configuration = () => {
 	initialConfig = merge(initialConfig, OpenUI5Config);
 };
 
-
 const initConfiguration = () => {
 	if (initialized) {
 		return;
@@ -142,9 +148,8 @@ export {
 	getTheme,
 	getRTL,
 	getLanguage,
-	getUseDefaultLanguage,
+	getFetchDefaultLanguage,
 	getNoConflict,
 	getCalendarType,
 	getFormatSettings,
-	getAssetsPath,
 };

package/dist/Keys.js

@@ -105,8 +105,12 @@ const KeyCodes = {
 
 const isEnter = event => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && !hasModifierKeys(event);
 
+const isEnterShift = event => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && checkModifierKeys(event, false, false, true);
+
 const isSpace = event => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && !hasModifierKeys(event);
 
+const isSpaceShift = event => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && checkModifierKeys(event, false, false, true);
+
 const isLeft = event => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && !hasModifierKeys(event);
 
 const isRight = event => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && !hasModifierKeys(event);
@@ -115,6 +119,26 @@ const isUp = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up
 
 const isDown = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && !hasModifierKeys(event);
 
+const isLeftCtrl = event => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, true, false, false);
+
+const isRightCtrl = event => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, true, false, false);
+
+const isUpCtrl = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, false);
+
+const isDownCtrl = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, false);
+
+const isUpShift = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, false, false, true);
+
+const isDownShift = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isLeftShift = event => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, false, false, true);
+
+const isRightShift = event => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, false, false, true);
+
+const isUpShiftCtrl = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, true);
+
+const isDownShiftCtrl = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, true);
+
 const isHome = event => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && !hasModifierKeys(event);
 
 const isEnd = event => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && !hasModifierKeys(event);
@@ -139,12 +163,20 @@ const isPageDown = event => (event.key ? event.key === "PageDown" : event.keyCod
 
 const isPageUpShift = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, false, true);
 
+const isPageUpAlt = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, true, false);
+
 const isPageDownShift = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, false, true);
 
+const isPageDownAlt = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, true, false);
+
 const isPageUpShiftCtrl = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, true, false, true);
 
 const isPageDownShiftCtrl = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, true, false, true);
 
+const isPlus = event => (event.key ? event.key === "+" : event.keyCode === KeyCodes.PLUS) || (event.keyCode === KeyCodes.NUMPAD_PLUS && !hasModifierKeys(event));
+
+const isMinus = event => (event.key ? event.key === "-" : event.keyCode === KeyCodes.MINUS) || (event.keyCode === KeyCodes.NUMPAD_MINUS && !hasModifierKeys(event));
+
 const isShow = event => {
 	if (event.key) {
 		return isF4(event) || isShowByArrows(event);
@@ -159,6 +191,8 @@ const isF4 = event => {
 
 const isF4Shift = event => (event.key ? event.key === "F4" : event.keyCode === KeyCodes.F4) && checkModifierKeys(event, false, false, true);
 
+const isF7 = event => (event.key ? event.key === "F7" : event.keyCode === KeyCodes.F7) && !hasModifierKeys(event);
+
 const isShowByArrows = event => {
 	return ((event.key === "ArrowDown" || event.key === "Down") || (event.key === "ArrowUp" || event.key === "Up")) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ true, /* Shift */ false);
 };
@@ -171,13 +205,27 @@ const checkModifierKeys = (event, bCtrlKey, bAltKey, bShiftKey) => event.shiftKe
 
 export {
 	isEnter,
+	isEnterShift,
 	isSpace,
+	isSpaceShift,
 	isLeft,
 	isRight,
 	isUp,
 	isDown,
+	isLeftCtrl,
+	isRightCtrl,
+	isUpCtrl,
+	isDownCtrl,
+	isUpShift,
+	isDownShift,
+	isLeftShift,
+	isRightShift,
+	isUpShiftCtrl,
+	isDownShiftCtrl,
 	isHome,
 	isEnd,
+	isPlus,
+	isMinus,
 	isHomeCtrl,
 	isEndCtrl,
 	isEscape,
@@ -188,10 +236,13 @@ export {
 	isShow,
 	isF4,
 	isF4Shift,
+	isF7,
 	isPageUp,
 	isPageDown,
 	isPageUpShift,
+	isPageUpAlt,
 	isPageDownShift,
+	isPageDownAlt,
 	isPageUpShiftCtrl,
 	isPageDownShiftCtrl,
 };

package/dist/MediaRange.js

@@ -0,0 +1,109 @@
+const querySets = {};
+
+/**
+ * Initializes a screen width media query range set.
+ *
+ * This initialization step makes the range set ready to be used for one of the other functions in namespace <code>MediaRange</code>.
+ *
+ * A range set can be defined as shown in the following example:
+ * <pre>
+ * MediaRange.initRangeSet("MyRangeSet", [200, 400], ["Small", "Medium", "Large"]);
+ * </pre>
+ * This example defines the following named ranges:
+ * <ul>
+ * <li><code>"Small"</code>: For screens smaller than 200 pixels.</li>
+ * <li><code>"Medium"</code>: For screens greater than or equal to 200 pixels and smaller than 400 pixels.</li>
+ * <li><code>"Large"</code>: For screens greater than or equal to 400 pixels.</li>
+ * </ul>
+ *
+ * @param {string} name The name of the range set to be initialized.
+ * The name must be a valid id and consist only of letters and numeric digits.
+ *
+ * @param {int[]} [borders] The range borders
+ *
+ * @param {string[]} [names] The names of the ranges. The names must be a valid id and consist only of letters and digits.
+ *
+ * @name MediaRange.initRangeSet
+ * @function
+ * @public
+ */
+const _initRangeSet = (name, borders, names) => {
+	querySets[name] = {
+		borders,
+		names,
+	};
+};
+
+/**
+ * Returns information about the current active range of the range set with the given name.
+ *
+ * If the optional parameter <code>width</code> is given, the active range will be determined for that width,
+ * otherwise it is determined for the current window size.
+ *
+ * @param {string} name The name of the range set. The range set must be initialized beforehand ({@link MediaRange.initRangeSet})
+ * @param {int} [width] An optional width, based on which the range should be determined;
+ *             If <code>width</code> is not provided, the window size will be used.
+ * @returns {string} The name of the current active interval of the range set.
+ *
+ * @name MediaRange.getCurrentRange
+ * @function
+ * @public
+ */
+const _getCurrentRange = (name, width = window.innerWidth) => {
+	const querySet = querySets[name];
+	let i = 0;
+
+	if (!querySet) {
+		return null;
+	}
+
+	for (; i < querySet.borders.length; i++) {
+		if (width < querySet.borders[i]) {
+			return querySet.names[i];
+		}
+	}
+
+	return querySet.names[i];
+};
+
+/**
+ * Enumeration containing the names and settings of predefined screen width media query range sets.
+ *
+ * @namespace
+ * @name MediaRange.RANGESETS
+ * @public
+ */
+const RANGESETS = {
+	/**
+	 * A 4-step range set (S-M-L-XL).
+	 *
+	 * The ranges of this set are:
+	 * <ul>
+	 * <li><code>"S"</code>: For screens smaller than 600 pixels.</li>
+	 * <li><code>"M"</code>: For screens greater than or equal to 600 pixels and smaller than 1024 pixels.</li>
+	 * <li><code>"L"</code>: For screens greater than or equal to 1024 pixels and smaller than 1440 pixels.</li>
+	 * <li><code>"XL"</code>: For screens greater than or equal to 1440 pixels.</li>
+	 * </ul>
+	 *
+	 * @name MediaRange.RANGESETS.RANGE_4STEPS
+	 * @public
+	 */
+	RANGE_4STEPS: "4Step",
+};
+
+/**
+ * API for screen width changes.
+ *
+ * @namespace
+ * @name MediaRange
+ */
+
+const MediaRange = {
+	RANGESETS,
+	initRangeSet: _initRangeSet,
+	getCurrentRange: _getCurrentRange,
+};
+
+MediaRange.initRangeSet(MediaRange.RANGESETS.RANGE_4STEPS, [600, 1024, 1440], ["S", "M", "L", "XL"]);
+
+export default MediaRange;

package/{src/util/parseProperties.js → dist/PropertiesFileFormat.js}

@@ -15,6 +15,12 @@ const mEscapes = {
 	"\\t": "\t",
 };
 
+/**
+ * Parses a .properties format
+ * @param {string} sText the contents a of a .properties file
+ * @returns a object with key/value pairs parsed from the .properties file format
+ * @public
+ */
 const parseProperties = sText => {
 	const properties = {},
 		aLines = sText.split(rLines);

package/dist/Render.js

@@ -0,0 +1,173 @@
+import EventProvider from "./EventProvider.js";
+import RenderQueue from "./RenderQueue.js";
+import { getAllRegisteredTags } from "./CustomElementsRegistry.js";
+import { isRtlAware } from "./locale/RTLAwareRegistry.js";
+
+const registeredElements = new Set();
+const eventProvider = new EventProvider();
+
+const invalidatedWebComponents = new RenderQueue(); // Queue for invalidated web components
+
+let renderTaskPromise,
+	renderTaskPromiseResolve;
+
+let mutationObserverTimer;
+
+let queuePromise;
+
+/**
+ * Schedules a render task (if not already scheduled) to render the component
+ *
+ * @param webComponent
+ * @returns {Promise}
+ */
+const renderDeferred = async webComponent => {
+	// Enqueue the web component
+	invalidatedWebComponents.add(webComponent);
+
+	// Schedule a rendering task
+	await scheduleRenderTask();
+};
+
+/**
+ * Renders a component synchronously and adds it to the registry of rendered components
+ *
+ * @param webComponent
+ */
+const renderImmediately = webComponent => {
+	eventProvider.fireEvent("beforeComponentRender", webComponent);
+	registeredElements.add(webComponent);
+	webComponent._render();
+};
+
+/**
+ * Cancels the rendering of a component, if awaiting to be rendered, and removes it from the registry of rendered components
+ *
+ * @param webComponent
+ */
+const cancelRender = webComponent => {
+	invalidatedWebComponents.remove(webComponent);
+	registeredElements.delete(webComponent);
+};
+
+/**
+ * Schedules a rendering task, if not scheduled already
+ */
+const scheduleRenderTask = async () => {
+	if (!queuePromise) {
+		queuePromise = new Promise(resolve => {
+			window.requestAnimationFrame(() => {
+				// Render all components in the queue
+
+				// console.log(`--------------------RENDER TASK START------------------------------`); // eslint-disable-line
+				invalidatedWebComponents.process(renderImmediately);
+				// console.log(`--------------------RENDER TASK END------------------------------`); // eslint-disable-line
+
+				// Resolve the promise so that callers of renderDeferred can continue
+				queuePromise = null;
+				resolve();
+
+				// Wait for Mutation observer before the render task is considered finished
+				if (!mutationObserverTimer) {
+					mutationObserverTimer = setTimeout(() => {
+						mutationObserverTimer = undefined;
+						if (invalidatedWebComponents.isEmpty()) {
+							_resolveTaskPromise();
+						}
+					}, 200);
+				}
+			});
+		});
+	}
+
+	await queuePromise;
+};
+
+/**
+ * return a promise that will be resolved once all invalidated web components are rendered
+ */
+const whenDOMUpdated = () => {
+	if (renderTaskPromise) {
+		return renderTaskPromise;
+	}
+
+	renderTaskPromise = new Promise(resolve => {
+		renderTaskPromiseResolve = resolve;
+		window.requestAnimationFrame(() => {
+			if (invalidatedWebComponents.isEmpty()) {
+				renderTaskPromise = undefined;
+				resolve();
+			}
+		});
+	});
+
+	return renderTaskPromise;
+};
+
+const whenAllCustomElementsAreDefined = () => {
+	const definedPromises = getAllRegisteredTags().map(tag => customElements.whenDefined(tag));
+	return Promise.all(definedPromises);
+};
+
+const renderFinished = async () => {
+	await whenAllCustomElementsAreDefined();
+	await whenDOMUpdated();
+};
+
+const _resolveTaskPromise = () => {
+	if (!invalidatedWebComponents.isEmpty()) {
+		// More updates are pending. Resolve will be called again
+		return;
+	}
+
+	if (renderTaskPromiseResolve) {
+		renderTaskPromiseResolve();
+		renderTaskPromiseResolve = undefined;
+		renderTaskPromise = undefined;
+	}
+};
+
+/**
+ * Re-renders all UI5 Elements on the page, with the option to specify filters to rerender only some components.
+ *
+ * Usage:
+ * reRenderAllUI5Elements() -> re-renders all components
+ * reRenderAllUI5Elements({tag: "ui5-button"}) -> re-renders only instances of ui5-button
+ * reRenderAllUI5Elements({rtlAware: true}) -> re-renders only rtlAware components
+ * reRenderAllUI5Elements({languageAware: true}) -> re-renders only languageAware components
+ * reRenderAllUI5Elements({rtlAware: true, languageAware: true}) -> re-renders components that are rtlAware or languageAware
+ * etc...
+ *
+ * @public
+ * @param {Object|undefined} filters - Object with keys that can be "rtlAware" or "languageAware"
+ * @returns {Promise<void>}
+ */
+const reRenderAllUI5Elements = async filters => {
+	registeredElements.forEach(element => {
+		const tag = element.constructor.getMetadata().getTag();
+		const rtlAware = isRtlAware(element.constructor);
+		const languageAware = element.constructor.getMetadata().isLanguageAware();
+		if (!filters || (filters.tag === tag) || (filters.rtlAware && rtlAware) || (filters.languageAware && languageAware)) {
+			renderDeferred(element);
+		}
+	});
+	await renderFinished();
+};
+
+const attachBeforeComponentRender = listener => {
+	eventProvider.attachEvent("beforeComponentRender", listener);
+};
+
+const detachBeforeComponentRender = listener => {
+	eventProvider.detachEvent("beforeComponentRender", listener);
+};
+
+export {
+	renderDeferred,
+	renderImmediately,
+	cancelRender,
+	renderFinished,
+	reRenderAllUI5Elements,
+	attachBeforeComponentRender,
+	detachBeforeComponentRender,
+};