@ui5/webcomponents-base 0.0.0-e818f286e → 0.0.0-ee3bbe46b

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/MarkedEvents.ts

@@ -0,0 +1,20 @@
+const markedEvents = new WeakMap<Event, string>();
+
+/**
+ * Marks the given event with random marker.
+ */
+const markEvent = (event: Event, value: string) => {
+	markedEvents.set(event, value);
+};
+
+/**
+ * Returns the marker for the given event.
+ */
+const getEventMark = (event: Event): string | undefined => {
+	return markedEvents.get(event);
+};
+
+export {
+	markEvent,
+	getEventMark,
+};

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

@@ -1,4 +1,37 @@
-const querySets = {};
+type Range = Map<string, Array<number>>;
+
+const mediaRanges = new Map<string, Range>();
+
+const DEAFULT_RANGE_SET: Range = new Map<string, Array<number>>();
+DEAFULT_RANGE_SET.set("S", [0, 599]);
+DEAFULT_RANGE_SET.set("M", [600, 1023]);
+DEAFULT_RANGE_SET.set("L", [1024, 1439]);
+DEAFULT_RANGE_SET.set("XL", [1440, Infinity]);
+
+/**
+ * Enumeration containing the names and settings of predefined screen width media query range sets.
+ *
+ * @namespace
+ * @name MediaRange.RANGESETS
+ * @public
+ */
+ enum 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",
+}
 
 /**
  * Initializes a screen width media query range set.
@@ -18,20 +51,11 @@ 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.
- *
+ * @param {Range} [range] The given range set.
  * @name MediaRange.initRangeSet
- * @function
- * @public
  */
-const _initRangeSet = (name, borders, names) => {
-	querySets[name] = {
-		borders,
-		names,
-	};
+const initRangeSet = (name: string, range: Range) => {
+	mediaRanges.set(name, range);
 };
 
 /**
@@ -41,54 +65,31 @@ const _initRangeSet = (name, borders, names) => {
  * 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.
+ * @param {number} [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;
+const getCurrentRange = (name: string, width = window.innerWidth): string => {
+	let rangeSet = mediaRanges.get(name);
 
-	if (!querySet) {
-		return null;
+	if (!rangeSet) {
+		rangeSet = mediaRanges.get(RANGESETS.RANGE_4STEPS)!;
 	}
 
-	for (; i < querySet.borders.length; i++) {
-		if (width < querySet.borders[i]) {
-			return querySet.names[i];
-		}
-	}
+	let currentRangeName;
+	const effectiveWidth = Math.floor(width);
 
-	return querySet.names[i];
-};
+	rangeSet.forEach((value, key) => {
+		if (effectiveWidth >= value[0] && effectiveWidth <= value[1]) {
+			currentRangeName = key;
+		}
+	});
 
-/**
- * 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",
+	return currentRangeName || [...rangeSet.keys()][0];
 };
 
 /**
@@ -100,10 +101,10 @@ const RANGESETS = {
 
 const MediaRange = {
 	RANGESETS,
-	initRangeSet: _initRangeSet,
-	getCurrentRange: _getCurrentRange,
+	initRangeSet,
+	getCurrentRange,
 };
 
-MediaRange.initRangeSet(MediaRange.RANGESETS.RANGE_4STEPS, [600, 1024, 1440], ["S", "M", "L", "XL"]);
+MediaRange.initRangeSet(MediaRange.RANGESETS.RANGE_4STEPS, DEAFULT_RANGE_SET);
 
 export default MediaRange;

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) {

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

@@ -1,17 +1,22 @@
 import VersionInfo from "./generated/VersionInfo.js";
 import getSharedResource from "./getSharedResource.js";
 
-let currentRuntimeIndex;
+type RuntimeData = VersionInfo & {
+	alias: string,
+	description: string,
+};
+
+let currentRuntimeIndex: number;
 let currentRuntimeAlias = "";
 
-const compareCache = new Map();
+const compareCache = new Map<string, number>();
 
 /**
  * Central registry where all runtimes register themselves by pushing an object.
  * The index in the registry servers as an ID for the runtime.
  * @type {*}
  */
-const Runtimes = getSharedResource("Runtimes", []);
+const Runtimes = getSharedResource<Array<RuntimeData>>("Runtimes", []);
 
 /**
  * Registers the current runtime in the shared runtimes resource registry
@@ -19,10 +24,12 @@ const Runtimes = getSharedResource("Runtimes", []);
 const registerCurrentRuntime = () => {
 	if (currentRuntimeIndex === undefined) {
 		currentRuntimeIndex = Runtimes.length;
+		const versionInfo = VersionInfo;
+
 		Runtimes.push({
-			...VersionInfo,
+			...versionInfo,
 			alias: currentRuntimeAlias,
-			description: `Runtime ${currentRuntimeIndex} - ver ${VersionInfo.version}${currentRuntimeAlias ? ` (${currentRuntimeAlias})` : ""}`,
+			description: `Runtime ${currentRuntimeIndex} - ver ${versionInfo.version}${currentRuntimeAlias ? ` (${currentRuntimeAlias})` : ""}`,
 		});
 	}
 };
@@ -41,10 +48,10 @@ const getCurrentRuntimeIndex = () => {
  * @param index2 The index of the second runtime to compare
  * @returns {number}
  */
-const compareRuntimes = (index1, index2) => {
+const compareRuntimes = (index1: number, index2: number) => {
 	const cacheIndex = `${index1},${index2}`;
 	if (compareCache.has(cacheIndex)) {
-		return compareCache.get(cacheIndex);
+		return compareCache.get(cacheIndex)!;
 	}
 
 	const runtime1 = Runtimes[index1];
@@ -90,7 +97,7 @@ const compareRuntimes = (index1, index2) => {
  * Set an alias for the the current app/library/microfrontend which will appear in debug messages and console warnings
  * @param alias
  */
-const setRuntimeAlias = alias => {
+const setRuntimeAlias = (alias: string) => {
 	currentRuntimeAlias = alias;
 };
 

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

@@ -4,6 +4,10 @@ import { renderFinished } from "./Render.js";
 import getEffectiveContentDensity from "./util/getEffectiveContentDensity.js";
 import { getEffectiveScopingSuffixForTag } from "./CustomElementsScopeUtils.js";
 import getEffectiveDir from "./locale/getEffectiveDir.js";
+import type UI5Element from "./UI5Element.js";
+
+const pureTagName = "ui5-static-area-item";
+const popupIntegrationAttr = "data-sap-ui-integration-popup-content";
 
 /**
  *
@@ -12,6 +16,9 @@ import getEffectiveDir from "./locale/getEffectiveDir.js";
  * @private
  */
 class StaticAreaItem extends HTMLElement {
+	_rendered: boolean;
+	ownerElement?: UI5Element;
+
 	constructor() {
 		super();
 		this._rendered = false;
@@ -19,26 +26,25 @@ class StaticAreaItem extends HTMLElement {
 	}
 
 	/**
-	 * @protected
-	 * @param ownerElement The UI5Element instance that owns this static area item
+	 * @param {UI5Element} ownerElement the UI5Element instance that owns this static area item
 	 */
-	setOwnerElement(ownerElement) {
+	setOwnerElement(ownerElement: UI5Element) {
 		this.ownerElement = ownerElement;
 		this.classList.add(this.ownerElement._id); // used for getting the popover in the tests
 		if (this.ownerElement.hasAttribute("data-ui5-static-stable")) {
-			this.setAttribute("data-ui5-stable", this.ownerElement.getAttribute("data-ui5-static-stable")); // stable selector
+			this.setAttribute("data-ui5-stable", this.ownerElement.getAttribute("data-ui5-static-stable")!); // stable selector
 		}
 	}
 
 	/**
 	 * Updates the shadow root of the static area item with the latest state, if rendered
-	 * @protected
 	 */
 	update() {
 		if (this._rendered) {
+			this._updateAdditionalAttrs();
 			this._updateContentDensity();
 			this._updateDirection();
-			updateShadowRoot(this.ownerElement, true);
+			updateShadowRoot(this.ownerElement!, true);
 		}
 	}
 
@@ -47,7 +53,7 @@ class StaticAreaItem extends HTMLElement {
 	 * @private
 	 */
 	_updateContentDensity() {
-		if (getEffectiveContentDensity(this.ownerElement) === "compact") {
+		if (getEffectiveContentDensity(this.ownerElement!) === "compact") {
 			this.classList.add("sapUiSizeCompact");
 			this.classList.add("ui5-content-density-compact");
 		} else {
@@ -57,14 +63,21 @@ class StaticAreaItem extends HTMLElement {
 	}
 
 	_updateDirection() {
-		const dir = getEffectiveDir(this.ownerElement);
-		if (dir) {
-			this.setAttribute("dir", dir);
-		} else {
-			this.removeAttribute("dir");
+		if (this.ownerElement) {
+			const dir = getEffectiveDir(this.ownerElement);
+			if (dir) {
+				this.setAttribute("dir", dir);
+			} else {
+				this.removeAttribute("dir");
+			}
 		}
 	}
 
+	_updateAdditionalAttrs() {
+		this.setAttribute(pureTagName, "");
+		this.setAttribute(popupIntegrationAttr, "");
+	}
+
 	/**
 	 * @protected
 	 * Returns reference to the DOM element where the current fragment is added.
@@ -73,20 +86,19 @@ class StaticAreaItem extends HTMLElement {
 		this._updateContentDensity();
 		if (!this._rendered) {
 			this._rendered = true;
-			updateShadowRoot(this.ownerElement, true);
+			updateShadowRoot(this.ownerElement!, true);
 		}
 		await renderFinished(); // Wait for the content of the ui5-static-area-item to be rendered
 		return this.shadowRoot;
 	}
 
 	static getTag() {
-		const pureTag = "ui5-static-area-item";
-		const suffix = getEffectiveScopingSuffixForTag(pureTag);
+		const suffix = getEffectiveScopingSuffixForTag(pureTagName);
 		if (!suffix) {
-			return pureTag;
+			return pureTagName;
 		}
 
-		return `${pureTag}-${suffix}`;
+		return `${pureTagName}-${suffix}`;
 	}
 
 	static createInstance() {
@@ -94,7 +106,7 @@ class StaticAreaItem extends HTMLElement {
 			customElements.define(StaticAreaItem.getTag(), StaticAreaItem);
 		}
 
-		return document.createElement(this.getTag());
+		return document.createElement(this.getTag()) as StaticAreaItem;
 	}
 }