@ui5/webcomponents-base 0.0.0-deac3098a → 0.0.0-e0658a650

package/src/Keys.ts

@@ -0,0 +1,295 @@
+enum KeyCodes {
+	BACKSPACE = 8,
+	TAB = 9,
+	ENTER = 13,
+	SHIFT = 16,
+	CONTROL = 17,
+	ALT = 18,
+	BREAK = 19,
+	CAPS_LOCK = 20,
+	ESCAPE = 27,
+	SPACE = 32,
+	PAGE_UP = 33,
+	PAGE_DOWN = 34,
+	END = 35,
+	HOME = 36,
+	ARROW_LEFT = 37,
+	ARROW_UP = 38,
+	ARROW_RIGHT = 39,
+	ARROW_DOWN = 40,
+	PRINT = 44,
+	INSERT = 45,
+	DELETE = 46,
+	DIGIT_0 = 48,
+	DIGIT_1 = 49,
+	DIGIT_2 = 50,
+	DIGIT_3 = 51,
+	DIGIT_4 = 52,
+	DIGIT_5 = 53,
+	DIGIT_6 = 54,
+	DIGIT_7 = 55,
+	DIGIT_8 = 56,
+	DIGIT_9 = 57,
+	A = 65,
+	B = 66,
+	C = 67,
+	D = 68,
+	E = 69,
+	F = 70,
+	G = 71,
+	H = 72,
+	I = 73,
+	J = 74,
+	K = 75,
+	L = 76,
+	M = 77,
+	N = 78,
+	O = 79,
+	P = 80,
+	Q = 81,
+	R = 82,
+	S = 83,
+	T = 84,
+	U = 85,
+	V = 86,
+	W = 87,
+	X = 88,
+	Y = 89,
+	Z = 90,
+	WINDOWS = 91,
+	CONTEXT_MENU = 93,
+	TURN_OFF = 94,
+	SLEEP = 95,
+	NUMPAD_0 = 96,
+	NUMPAD_1 = 97,
+	NUMPAD_2 = 98,
+	NUMPAD_3 = 99,
+	NUMPAD_4 = 100,
+	NUMPAD_5 = 101,
+	NUMPAD_6 = 102,
+	NUMPAD_7 = 103,
+	NUMPAD_8 = 104,
+	NUMPAD_9 = 105,
+	NUMPAD_ASTERISK = 106,
+	NUMPAD_PLUS = 107,
+	NUMPAD_MINUS = 109,
+	NUMPAD_COMMA = 110,
+	NUMPAD_SLASH = 111,
+	F1 = 112,
+	F2 = 113,
+	F3 = 114,
+	F4 = 115,
+	F5 = 116,
+	F6 = 117,
+	F7 = 118,
+	F8 = 119,
+	F9 = 120,
+	F10 = 121,
+	F11 = 122,
+	F12 = 123,
+	NUM_LOCK = 144,
+	SCROLL_LOCK = 145,
+	OPEN_BRACKET = 186,
+	PLUS = 187,
+	COMMA = 188,
+	SLASH = 189,
+	DOT = 190,
+	PIPE = 191,
+	SEMICOLON = 192,
+	MINUS = 219,
+	GREAT_ACCENT = 220,
+	EQUALS = 221,
+	SINGLE_QUOTE = 222,
+	BACKSLASH = 226,
+}
+
+const isEnter = (event: KeyboardEvent) => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && !hasModifierKeys(event);
+
+const isEnterShift = (event: KeyboardEvent) => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && checkModifierKeys(event, false, false, true);
+
+const isSpace = (event: KeyboardEvent) => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && !hasModifierKeys(event);
+
+const isSpaceShift = (event: KeyboardEvent) => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && checkModifierKeys(event, false, false, true);
+
+const isSpaceCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && checkModifierKeys(event, true, false, false);
+
+const isLeft = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && !hasModifierKeys(event);
+
+const isRight = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && !hasModifierKeys(event);
+
+const isUp = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && !hasModifierKeys(event);
+
+const isDown = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && !hasModifierKeys(event);
+
+const isLeftCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, true, false, false);
+
+const isRightCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, true, false, false);
+
+const isUpCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, false);
+
+const isDownCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, false);
+
+const isUpShift = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, false, false, true);
+
+const isDownShift = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isUpAlt = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, false, true, false);
+
+const isDownAlt = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, false, true, false);
+
+const isLeftShift = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, false, false, true);
+
+const isRightShift = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, false, false, true);
+
+const isLeftShiftCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, true, false, true);
+
+const isRightShiftCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, true, false, true);
+
+const isUpShiftCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, true);
+
+const isDownShiftCtrl = (event: KeyboardEvent) => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, true);
+
+const isHome = (event: KeyboardEvent) => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && !hasModifierKeys(event);
+
+const isEnd = (event: KeyboardEvent) => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && !hasModifierKeys(event);
+
+const isHomeCtrl = (event: KeyboardEvent) => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && checkModifierKeys(event, true, false, false);
+
+const isHomeShift = (event: KeyboardEvent) => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && checkModifierKeys(event, false, false, true);
+
+const isEndCtrl = (event: KeyboardEvent) => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && checkModifierKeys(event, true, false, false);
+
+const isEndShift = (event: KeyboardEvent) => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && checkModifierKeys(event, false, false, true);
+
+const isEscape = (event: KeyboardEvent) => (event.key ? event.key === "Escape" || event.key === "Esc" : event.keyCode === KeyCodes.ESCAPE) && !hasModifierKeys(event);
+
+const isTabNext = (event: KeyboardEvent) => (event.key ? event.key === "Tab" : event.keyCode === KeyCodes.TAB) && !hasModifierKeys(event);
+
+const isTabPrevious = (event: KeyboardEvent) => (event.key ? event.key === "Tab" : event.keyCode === KeyCodes.TAB) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ false, /* Shift */ true);
+
+const isBackSpace = (event: KeyboardEvent) => (event.key ? event.key === "Backspace" : event.keyCode === KeyCodes.BACKSPACE) && !hasModifierKeys(event);
+
+const isDelete = (event: KeyboardEvent) => (event.key ? event.key === "Delete" : event.keyCode === KeyCodes.DELETE) && !hasModifierKeys(event);
+
+const isDeleteShift = (event: KeyboardEvent) => (event.key ? event.key === "Delete" : event.keyCode === KeyCodes.DELETE) && checkModifierKeys(event, false, false, true);
+
+const isInsertShift = (event: KeyboardEvent) => (event.key ? event.key === "Insert" : event.keyCode === KeyCodes.DELETE) && checkModifierKeys(event, false, false, true);
+
+const isInsertCtrl = (event: KeyboardEvent) => (event.key ? event.key === "Insert" : event.keyCode === KeyCodes.DELETE) && checkModifierKeys(event, true, false, false);
+
+const isPageUp = (event: KeyboardEvent) => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && !hasModifierKeys(event);
+
+const isPageDown = (event: KeyboardEvent) => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && !hasModifierKeys(event);
+
+const isPageUpShift = (event: KeyboardEvent) => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, false, true);
+
+const isPageUpAlt = (event: KeyboardEvent) => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, true, false);
+
+const isPageDownShift = (event: KeyboardEvent) => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isPageDownAlt = (event: KeyboardEvent) => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, true, false);
+
+const isPageUpShiftCtrl = (event: KeyboardEvent) => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, true, false, true);
+
+const isPageDownShiftCtrl = (event: KeyboardEvent) => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, true, false, true);
+
+const isPlus = (event: KeyboardEvent) => (event.key ? event.key === "+" : event.keyCode === KeyCodes.PLUS) || (event.keyCode === KeyCodes.NUMPAD_PLUS && !hasModifierKeys(event));
+
+const isMinus = (event: KeyboardEvent) => (event.key ? event.key === "-" : event.keyCode === KeyCodes.MINUS) || (event.keyCode === KeyCodes.NUMPAD_MINUS && !hasModifierKeys(event));
+
+const isShow = (event: KeyboardEvent) => {
+	if (event.key) {
+		return isF4(event) || isShowByArrows(event);
+	}
+
+	return (event.keyCode === KeyCodes.F4 && !hasModifierKeys(event)) || (event.keyCode === KeyCodes.ARROW_DOWN && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ true, /* Shift */ false));
+};
+
+const isF4 = (event: KeyboardEvent) => {
+	return event.key === "F4" && !hasModifierKeys(event);
+};
+
+const isF4Shift = (event: KeyboardEvent) => (event.key ? event.key === "F4" : event.keyCode === KeyCodes.F4) && checkModifierKeys(event, false, false, true);
+
+const isF6Next = (event: KeyboardEvent) => ((event.key ? event.key === "F6" : event.keyCode === KeyCodes.F6) && checkModifierKeys(event, false, false, false))
+	|| ((event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, true, false));
+
+const isF6Previous = (event: KeyboardEvent) => ((event.key ? event.key === "F6" : event.keyCode === KeyCodes.F6) && checkModifierKeys(event, false, false, true))
+	|| ((event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, true, false));
+
+const isF7 = (event: KeyboardEvent) => (event.key ? event.key === "F7" : event.keyCode === KeyCodes.F7) && !hasModifierKeys(event);
+
+const isShowByArrows = (event: KeyboardEvent) => {
+	return ((event.key === "ArrowDown" || event.key === "Down") || (event.key === "ArrowUp" || event.key === "Up")) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ true, /* Shift */ false);
+};
+
+const isShift = (event: KeyboardEvent) => event.key === "Shift" || event.keyCode === KeyCodes.SHIFT;
+
+const isCtrlA = (event: KeyboardEvent) => ((event.key === "A" || event.key === "a") || event.which === KeyCodes.A) && checkModifierKeys(event, true, false, false);
+
+const isCtrlV = (event: KeyboardEvent) => ((event.key === "V" || event.key === "v") || event.which === KeyCodes.V) && checkModifierKeys(event, true, false, false);
+
+const hasModifierKeys = (event: KeyboardEvent) => event.shiftKey || event.altKey || getCtrlKey(event);
+
+const getCtrlKey = (event: KeyboardEvent) => !!(event.metaKey || event.ctrlKey); // double negation doesn't have effect on boolean but ensures null and undefined are equivalent to false.
+
+const checkModifierKeys = (event: KeyboardEvent, bCtrlKey: boolean, bAltKey: boolean, bShiftKey: boolean) => event.shiftKey === bShiftKey && event.altKey === bAltKey && getCtrlKey(event) === bCtrlKey;
+
+export {
+	isEnter,
+	isEnterShift,
+	isSpace,
+	isSpaceShift,
+	isSpaceCtrl,
+	isLeft,
+	isRight,
+	isUp,
+	isDown,
+	isLeftCtrl,
+	isRightCtrl,
+	isUpCtrl,
+	isDownCtrl,
+	isUpShift,
+	isDownShift,
+	isUpAlt,
+	isDownAlt,
+	isLeftShift,
+	isRightShift,
+	isLeftShiftCtrl,
+	isRightShiftCtrl,
+	isUpShiftCtrl,
+	isDownShiftCtrl,
+	isHome,
+	isEnd,
+	isPlus,
+	isMinus,
+	isHomeCtrl,
+	isEndCtrl,
+	isHomeShift,
+	isEndShift,
+	isEscape,
+	isTabNext,
+	isTabPrevious,
+	isBackSpace,
+	isDelete,
+	isShow,
+	isF4,
+	isF4Shift,
+	isF6Previous,
+	isF6Next,
+	isF7,
+	isPageUp,
+	isPageDown,
+	isPageUpShift,
+	isPageUpAlt,
+	isPageDownShift,
+	isPageDownAlt,
+	isPageUpShiftCtrl,
+	isPageDownShiftCtrl,
+	isShift,
+	isCtrlA,
+	isCtrlV,
+	isDeleteShift,
+	isInsertShift,
+	isInsertCtrl,
+};

package/src/ManagedStyles.ts

@@ -0,0 +1,92 @@
+import createStyleInHead from "./util/createStyleInHead.js";
+import createLinkInHead from "./util/createLinkInHead.js";
+import { shouldUseLinks, getUrl } from "./CSP.js";
+import { StyleData, StyleDataCSP } from "./types.js";
+
+const getStyleId = (name: string, value: string) => {
+	return value ? `${name}|${value}` : name;
+};
+
+const createStyle = (data: StyleData, name: string, value = "") => {
+	const content = typeof data === "string" ? data : data.content;
+
+	if (shouldUseLinks()) {
+		const attributes = {} as Record<string, any>;
+		attributes[name] = value;
+		const href = getUrl((data as StyleDataCSP).packageName, (data as StyleDataCSP).fileName);
+		createLinkInHead(href, attributes);
+	} else if (document.adoptedStyleSheets) {
+		const stylesheet = new CSSStyleSheet();
+		stylesheet.replaceSync(content);
+		(stylesheet as Record<string, any>)._ui5StyleId = getStyleId(name, value); // set an id so that we can find the style later
+		document.adoptedStyleSheets = [...document.adoptedStyleSheets, stylesheet];
+	} else {
+		const attributes = {} as Record<string, any>;
+		attributes[name] = value;
+		createStyleInHead(content, attributes);
+	}
+};
+
+const updateStyle = (data: StyleData, name: string, value = "") => {
+	const content = typeof data === "string" ? data : data.content;
+
+	if (shouldUseLinks()) {
+		const link = document.querySelector(`head>link[${name}="${value}"]`) as HTMLLinkElement;
+		link.href = getUrl((data as StyleDataCSP).packageName, (data as StyleDataCSP).fileName);
+	} else if (document.adoptedStyleSheets) {
+		const stylesheet = document.adoptedStyleSheets.find(sh => (sh as Record<string, any>)._ui5StyleId === getStyleId(name, value));
+		if (stylesheet) {
+			stylesheet.replaceSync(content || "");
+		}
+	} else {
+		const style = document.querySelector(`head>style[${name}="${value}"]`);
+		if (style) {
+			style.textContent = content || "";
+		}
+	}
+};
+
+const hasStyle = (name: string, value = "") => {
+	if (shouldUseLinks()) {
+		return !!document.querySelector(`head>link[${name}="${value}"]`);
+	}
+
+	if (document.adoptedStyleSheets) {
+		return !!document.adoptedStyleSheets.find(sh => (sh as Record<string, any>)._ui5StyleId === getStyleId(name, value));
+	}
+
+	return !!document.querySelector(`head>style[${name}="${value}"]`);
+};
+
+const removeStyle = (name: string, value = "") => {
+	if (shouldUseLinks()) {
+		const linkElement = document.querySelector(`head>link[${name}="${value}"]`);
+		linkElement?.parentElement?.removeChild(linkElement);
+	} else if (document.adoptedStyleSheets) {
+		document.adoptedStyleSheets = document.adoptedStyleSheets.filter(sh => (sh as Record<string, any>)._ui5StyleId !== getStyleId(name, value));
+	} else {
+		const styleElement = document.querySelector(`head > style[${name}="${value}"]`);
+		styleElement?.parentElement?.removeChild(styleElement);
+	}
+};
+
+const createOrUpdateStyle = (data: StyleData, name: string, value = "") => {
+	if (hasStyle(name, value)) {
+		updateStyle(data, name, value);
+	} else {
+		createStyle(data, name, value);
+	}
+};
+
+export {
+	createStyle,
+	hasStyle,
+	updateStyle,
+	removeStyle,
+	createOrUpdateStyle,
+};
+
+export type {
+	StyleData,
+	StyleDataCSP,
+};

package/src/{MediaRange.js → MediaRange.ts}

@@ -1,4 +1,9 @@
-const querySets = {};
+const querySets = new Map<string, RangeSet>();
+
+type RangeSet = {
+	borders: Array<number>,
+	names: Array<string>,
+}
 
 /**
  * Initializes a screen width media query range set.
@@ -18,20 +23,15 @@ const querySets = {};
  *
  * @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] = {
+const _initRangeSet = (name: string, borders: Array<number>, names: Array<string>) => {
+	querySets.set(name, {
 		borders,
 		names,
-	};
+	});
 };
 
 /**
@@ -49,8 +49,8 @@ const _initRangeSet = (name, borders, names) => {
  * @function
  * @public
  */
-const _getCurrentRange = (name, width = window.innerWidth) => {
-	const querySet = querySets[name];
+const _getCurrentRange = (name: string, width = window.innerWidth) => {
+	const querySet = querySets.get(name);
 	let i = 0;
 
 	if (!querySet) {
@@ -73,7 +73,7 @@ const _getCurrentRange = (name, width = window.innerWidth) => {
  * @name MediaRange.RANGESETS
  * @public
  */
-const RANGESETS = {
+enum RANGESETS {
 	/**
 	 * A 4-step range set (S-M-L-XL).
 	 *
@@ -88,8 +88,8 @@ const RANGESETS = {
 	 * @name MediaRange.RANGESETS.RANGE_4STEPS
 	 * @public
 	 */
-	RANGE_4STEPS: "4Step",
-};
+	RANGE_4STEPS = "4Step",
+}
 
 /**
  * API for screen width changes.

package/src/{PropertiesFileFormat.js → PropertiesFileFormat.ts}

@@ -1,9 +1,9 @@
-const flatstr = typeof chrome === "object" || typeof v8 === "object" ? (s, iConcatOps) => {
+const flatstr = typeof window.chrome === "object" || typeof window.v8 === "object" ? (s: string, iConcatOps: number) => {
 	if (iConcatOps > 2 && 40 * iConcatOps > s.length) {
 		Number(s);
 	}
 	return s;
-} : s => s;
+} : (s: string) => s;
 
 const rLines = /(?:\r\n|\r|\n|^)[ \t\f]*/;
 const rEscapesOrSeparator = /(\\u[0-9a-fA-F]{0,4})|(\\.)|(\\$)|([ \t\f]*[ \t\f:=][ \t\f]*)/g;
@@ -21,20 +21,20 @@ const mEscapes = {
  * @returns a object with key/value pairs parsed from the .properties file format
  * @public
  */
-const parseProperties = sText => {
+const parseProperties = (sText: string) => {
 	const properties = {},
 		aLines = sText.split(rLines);
 
 	let sLine,
 		rMatcher,
 		sKey,
-		sValue,
+		sValue: string,
 		i,
 		m,
 		iLastIndex,
-		iConcatOps;
+		iConcatOps: number;
 
-	const append = s => {
+	const append = (s: string) => {
 		if (sValue) {
 			sValue = `${sValue}${s}`;
 			iConcatOps++;
@@ -66,7 +66,7 @@ const parseProperties = sText => {
 					}
 					append(String.fromCharCode(parseInt(m[1].slice(2), 16)));
 				} else if (m[2]) {
-					append(mEscapes[m[2]] || m[2].slice(1));
+					append(mEscapes[m[2] as keyof typeof mEscapes] || m[2].slice(1));
 				} else if (m[3]) {
 					sLine = aLines[++i];
 					iLastIndex = 0;
@@ -86,7 +86,7 @@ const parseProperties = sText => {
 				sKey = sValue;
 				sValue = "";
 			}
-			properties[sKey] = flatstr(sValue, sValue ? iConcatOps : 0);
+			(properties as Record<string, any>)[sKey] = flatstr(sValue, sValue ? iConcatOps! : 0);
 		}
 	}
 	return properties;

package/src/{Render.js → Render.ts}

@@ -2,18 +2,22 @@ import EventProvider from "./EventProvider.js";
 import RenderQueue from "./RenderQueue.js";
 import { getAllRegisteredTags } from "./CustomElementsRegistry.js";
 import { isRtlAware } from "./locale/RTLAwareRegistry.js";
+import type UI5Element from "./UI5Element.js";
+import { PromiseResolve, Timeout } from "./types.js";
 
-const registeredElements = new Set();
-const eventProvider = new EventProvider();
+type BeforeComponentRenderCallback = (webComponent: UI5Element) => void;
+
+const registeredElements = new Set<UI5Element>();
+const eventProvider = new EventProvider<UI5Element, void>();
 
 const invalidatedWebComponents = new RenderQueue(); // Queue for invalidated web components
 
-let renderTaskPromise,
-	renderTaskPromiseResolve;
+let renderTaskPromise: Promise<void> | undefined,
+	renderTaskPromiseResolve: PromiseResolve | undefined;
 
-let mutationObserverTimer;
+let mutationObserverTimer: Timeout | undefined;
 
-let queuePromise;
+let queuePromise: Promise<void> | null;
 
 /**
  * Schedules a render task (if not already scheduled) to render the component
@@ -21,7 +25,7 @@ let queuePromise;
  * @param webComponent
  * @returns {Promise}
  */
-const renderDeferred = async webComponent => {
+const renderDeferred = async (webComponent: UI5Element) => {
 	// Enqueue the web component
 	invalidatedWebComponents.add(webComponent);
 
@@ -34,7 +38,7 @@ const renderDeferred = async webComponent => {
  *
  * @param webComponent
  */
-const renderImmediately = webComponent => {
+const renderImmediately = (webComponent: UI5Element) => {
 	eventProvider.fireEvent("beforeComponentRender", webComponent);
 	registeredElements.add(webComponent);
 	webComponent._render();
@@ -45,7 +49,7 @@ const renderImmediately = webComponent => {
  *
  * @param webComponent
  */
-const cancelRender = webComponent => {
+const cancelRender = (webComponent: UI5Element) => {
 	invalidatedWebComponents.remove(webComponent);
 	registeredElements.delete(webComponent);
 };
@@ -55,7 +59,7 @@ const cancelRender = webComponent => {
  */
 const scheduleRenderTask = async () => {
 	if (!queuePromise) {
-		queuePromise = new Promise(resolve => {
+		queuePromise = new Promise<void>(resolve => {
 			window.requestAnimationFrame(() => {
 				// Render all components in the queue
 
@@ -91,7 +95,7 @@ const whenDOMUpdated = () => {
 		return renderTaskPromise;
 	}
 
-	renderTaskPromise = new Promise(resolve => {
+	renderTaskPromise = new Promise<void>(resolve => {
 		renderTaskPromiseResolve = resolve;
 		window.requestAnimationFrame(() => {
 			if (invalidatedWebComponents.isEmpty()) {
@@ -140,15 +144,16 @@ const _resolveTaskPromise = () => {
  * etc...
  *
  * @public
- * @param {Object|undefined} filters - Object with keys that can be "rtlAware" or "languageAware"
+ * @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();
-		const themeAware = element.constructor.getMetadata().isThemeAware();
+const reRenderAllUI5Elements = async (filters?: {tag?: string, rtlAware?: boolean, languageAware?: boolean, themeAware?: boolean}) => {
+	registeredElements.forEach((element: UI5Element) => {
+		const ctor = element.constructor as typeof UI5Element;
+		const tag = ctor.getMetadata().getTag();
+		const rtlAware = isRtlAware(ctor);
+		const languageAware = ctor.getMetadata().isLanguageAware();
+		const themeAware = ctor.getMetadata().isThemeAware();
 		if (!filters || (filters.tag === tag) || (filters.rtlAware && rtlAware) || (filters.languageAware && languageAware) || (filters.themeAware && themeAware)) {
 			renderDeferred(element);
 		}
@@ -156,11 +161,11 @@ const reRenderAllUI5Elements = async filters => {
 	await renderFinished();
 };
 
-const attachBeforeComponentRender = listener => {
+const attachBeforeComponentRender = (listener: BeforeComponentRenderCallback) => {
 	eventProvider.attachEvent("beforeComponentRender", listener);
 };
 
-const detachBeforeComponentRender = listener => {
+const detachBeforeComponentRender = (listener: BeforeComponentRenderCallback) => {
 	eventProvider.detachEvent("beforeComponentRender", listener);
 };
 

package/src/{RenderQueue.js → RenderQueue.ts}

@@ -1,12 +1,17 @@
+import type UI5Element from "./UI5Element.js";
+
 const MAX_PROCESS_COUNT = 10;
 
 class RenderQueue {
+	list: Array<UI5Element>;
+	lookup: Set<UI5Element>;
+
 	constructor() {
 		this.list = []; // Used to store the web components in order
 		this.lookup = new Set(); // Used for faster search
 	}
 
-	add(webComponent) {
+	add(webComponent: UI5Element) {
 		if (this.lookup.has(webComponent)) {
 			return;
 		}
@@ -15,7 +20,7 @@ class RenderQueue {
 		this.lookup.add(webComponent);
 	}
 
-	remove(webComponent) {
+	remove(webComponent: UI5Element) {
 		if (!this.lookup.has(webComponent)) {
 			return;
 		}
@@ -36,7 +41,7 @@ class RenderQueue {
 		return this.list.length === 0;
 	}
 
-	isAdded(webComponent) {
+	isAdded(webComponent: UI5Element) {
 		return this.lookup.has(webComponent);
 	}
 
@@ -46,9 +51,9 @@ class RenderQueue {
 	 *
 	 * @param callback - function with one argument (the web component to be processed)
 	 */
-	process(callback) {
+	process(callback: (el: UI5Element) => void) {
 		let webComponent;
-		const stats = new Map();
+		const stats = new Map<UI5Element, number>();
 
 		webComponent = this.shift();
 		while (webComponent) {