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

package/src/RenderScheduler.js

@@ -1,164 +1,43 @@
-import RenderQueue from "./RenderQueue.js";
-
-const MAX_RERENDER_COUNT = 10;
-
-// Tells whether a render task is currently scheduled
-let renderTaskId;
-
-// Queue for invalidated web components
-const invalidatedWebComponents = new RenderQueue();
-
-let renderTaskPromise,
-	renderTaskPromiseResolve,
-	taskResult;
-
-let mutationObserverTimer;
+import {
+	renderDeferred,
+	renderImmediately,
+	renderFinished,
+} from "./Render.js";
 
 /**
- * Class that manages the rendering/re-rendering of web components
- * This is always asynchronous
+ * @deprecated Use the Render.js module instead
  */
 class RenderScheduler {
-	constructor() {
-		throw new Error("Static class");
-	}
-
 	/**
-	 * Queues a web component for re-rendering
+	 * Schedules a render task (if not already scheduled) to render the component
+	 *
 	 * @param webComponent
+	 * @returns {Promise}
+	 * @deprecated Use renderDeferred from the Render.js module instead
 	 */
-	static renderDeferred(webComponent) {
-		// Enqueue the web component
-		const res = invalidatedWebComponents.add(webComponent);
-
-		// Schedule a rendering task
-		RenderScheduler.scheduleRenderTask();
-		return res;
-	}
-
-	static renderImmediately(webComponent) {
-		// Enqueue the web component
-		const res = invalidatedWebComponents.add(webComponent);
-
-		// Immediately start a render task
-		RenderScheduler.runRenderTask();
-		return res;
-	}
-
-	/**
-	 * Schedules a rendering task, if not scheduled already
-	 */
-	static scheduleRenderTask() {
-		if (!renderTaskId) {
-			// renderTaskId = window.setTimeout(RenderScheduler.renderWebComponents, 3000); // Task
-			// renderTaskId = Promise.resolve().then(RenderScheduler.renderWebComponents); // Micro task
-			renderTaskId = window.requestAnimationFrame(RenderScheduler.renderWebComponents); // AF
-		}
-	}
-
-	static runRenderTask() {
-		if (!renderTaskId) {
-			renderTaskId = 1; // prevent another rendering task from being scheduled, all web components should use this task
-			RenderScheduler.renderWebComponents();
-		}
-	}
-
-	static renderWebComponents() {
-		// console.log("------------- NEW RENDER TASK ---------------");
-
-		let webComponentInfo,
-			webComponent,
-			promise;
-		const renderStats = new Map();
-		while (webComponentInfo = invalidatedWebComponents.shift()) { // eslint-disable-line
-			webComponent = webComponentInfo.webComponent;
-			promise = webComponentInfo.promise;
-
-			const timesRerendered = renderStats.get(webComponent) || 0;
-			if (timesRerendered > MAX_RERENDER_COUNT) {
-				// console.warn("WARNING RERENDER", webComponent);
-				throw new Error(`Web component re-rendered too many times this task, max allowed is: ${MAX_RERENDER_COUNT}`);
-			}
-			webComponent._render();
-			promise._deferredResolve();
-			renderStats.set(webComponent, timesRerendered + 1);
-		}
-
-		// wait for Mutation observer just in case
-		if (!mutationObserverTimer) {
-			mutationObserverTimer = setTimeout(() => {
-				mutationObserverTimer = undefined;
-				if (invalidatedWebComponents.getList().length === 0) {
-					RenderScheduler._resolveTaskPromise();
-				}
-			}, 200);
-		}
-
-		renderTaskId = undefined;
+	static async renderDeferred(webComponent) {
+		console.log("RenderScheduler.renderDeferred is deprecated, please use renderDeferred, exported by Render.js instead"); // eslint-disable-line
+		await renderDeferred(webComponent);
 	}
 
 	/**
-	 * return a promise that will be resolved once all invalidated web components are rendered
+	 * Renders a component synchronously
+	 *
+	 * @param webComponent
+	 * @deprecated Use renderImmediately from the Render.js module instead
 	 */
-	static whenDOMUpdated() {
-		if (renderTaskPromise) {
-			return renderTaskPromise;
-		}
-
-		renderTaskPromise = new Promise(resolve => {
-			renderTaskPromiseResolve = resolve;
-			window.requestAnimationFrame(() => {
-				if (invalidatedWebComponents.getList().length === 0) {
-					renderTaskPromise = undefined;
-					resolve();
-				}
-			});
-		});
-
-		return renderTaskPromise;
-	}
-
-	static getNotDefinedComponents() {
-		return Array.from(document.querySelectorAll("*")).filter(el => el.localName.startsWith("ui5-") && !el.isUI5Element);
+	static renderImmediately(webComponent) {
+		console.log("RenderScheduler.renderImmediately is deprecated, please use renderImmediately, exported by Render.js instead"); // eslint-disable-line
+		return renderImmediately(webComponent);
 	}
 
 	/**
-	 * return a promise that will be resolved once all ui5 webcomponents on the page have their shadow root ready
+	 * @deprecated Use renderFinished from the Render.js module instead
+	 * @returns {Promise<void>}
 	 */
-	static async whenShadowDOMReady() {
-		const undefinedElements = this.getNotDefinedComponents();
-
-		const definedPromises = undefinedElements.map(
-		  el => customElements.whenDefined(el.localName)
-		);
-		const timeoutPromise = new Promise(resolve => setTimeout(resolve, 5000));
-
-		await Promise.race([Promise.all(definedPromises), timeoutPromise]);
-		const stillUndefined = this.getNotDefinedComponents();
-		if (stillUndefined.length) {
-			// eslint-disable-next-line
-			console.warn("undefined elements after 5 seconds are: " + [...stillUndefined].map(el => el.localName).join(" ; "));
-		}
-
-		return Promise.resolve();
-	}
-
 	static async whenFinished() {
-		await RenderScheduler.whenShadowDOMReady();
-		await RenderScheduler.whenDOMUpdated();
-	}
-
-	static _resolveTaskPromise() {
-		if (invalidatedWebComponents.getList().length > 0) {
-			// More updates are pending. Resolve will be called again
-			return;
-		}
-
-		if (renderTaskPromiseResolve) {
-			renderTaskPromiseResolve.call(this, taskResult);
-			renderTaskPromiseResolve = undefined;
-			renderTaskPromise = undefined;
-		}
+		console.log("RenderScheduler.whenFinished is deprecated, please use renderFinished, exported by Render.js instead"); // eslint-disable-line
+		await renderFinished();
 	}
 }
 

package/src/Runtimes.js

@@ -0,0 +1,107 @@
+import VersionInfo from "./generated/VersionInfo.js";
+import getSharedResource from "./getSharedResource.js";
+
+let currentRuntimeIndex;
+let currentRuntimeAlias = "";
+
+const compareCache = new Map();
+
+/**
+ * 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", []);
+
+/**
+ * Registers the current runtime in the shared runtimes resource registry
+ */
+const registerCurrentRuntime = () => {
+	if (currentRuntimeIndex === undefined) {
+		currentRuntimeIndex = Runtimes.length;
+		Runtimes.push({
+			...VersionInfo,
+			alias: currentRuntimeAlias,
+			description: `Runtime ${currentRuntimeIndex} - ver ${VersionInfo.version}${currentRuntimeAlias ? ` (${currentRuntimeAlias})` : ""}`,
+		});
+	}
+};
+
+/**
+ * Returns the index of the current runtime's object in the shared runtimes resource registry
+ * @returns {*}
+ */
+const getCurrentRuntimeIndex = () => {
+	return currentRuntimeIndex;
+};
+
+/**
+ * Compares two runtimes and returns 1 if the first is of a bigger version, -1 if the second is of a bigger version, and 0 if equal
+ * @param index1 The index of the first runtime to compare
+ * @param index2 The index of the second runtime to compare
+ * @returns {number}
+ */
+const compareRuntimes = (index1, index2) => {
+	const cacheIndex = `${index1},${index2}`;
+	if (compareCache.has(cacheIndex)) {
+		return compareCache.get(cacheIndex);
+	}
+
+	const runtime1 = Runtimes[index1];
+	const runtime2 = Runtimes[index2];
+
+	if (!runtime1 || !runtime2) {
+		throw new Error("Invalid runtime index supplied");
+	}
+
+	// If any of the two is a next version, bigger buildTime wins
+	if (runtime1.isNext || runtime2.isNext) {
+		return runtime1.buildTime - runtime2.buildTime;
+	}
+
+	// If major versions differ, bigger one wins
+	const majorDiff = runtime1.major - runtime2.major;
+	if (majorDiff) {
+		return majorDiff;
+	}
+
+	// If minor versions differ, bigger one wins
+	const minorDiff = runtime1.minor - runtime2.minor;
+	if (minorDiff) {
+		return minorDiff;
+	}
+
+	// If patch versions differ, bigger one wins
+	const patchDiff = runtime1.patch - runtime2.patch;
+	if (patchDiff) {
+		return patchDiff;
+	}
+
+	// Bigger suffix wins, f.e. rc10 > rc9
+	// Important: suffix is alphanumeric, must use natural compare
+	const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+	const result = collator.compare(runtime1.suffix, runtime2.suffix);
+
+	compareCache.set(cacheIndex, result);
+	return result;
+};
+
+/**
+ * Set an alias for the the current app/library/microfrontend which will appear in debug messages and console warnings
+ * @param alias
+ */
+const setRuntimeAlias = alias => {
+	currentRuntimeAlias = alias;
+};
+
+const getAllRuntimes = () => {
+	return Runtimes;
+};
+
+export {
+	getCurrentRuntimeIndex,
+	registerCurrentRuntime,
+	compareRuntimes,
+	setRuntimeAlias,
+	getAllRuntimes,
+};

package/src/StaticArea.js

@@ -1,35 +1,3 @@
-const getStaticAreaInstance = () => {
-	let staticArea = document.querySelector("ui5-static-area");
-
-	if (staticArea) {
-		return staticArea;
-	}
-
-	// Create static area if it is not present
-	const bodyElement = document.body;
-	staticArea = document.createElement("ui5-static-area");
-
-	return bodyElement.insertBefore(staticArea, bodyElement.firstChild);
-};
-
-const removeStaticArea = () => {
-	getStaticAreaInstance().destroy();
-};
-
-class StaticAreaElement extends HTMLElement {
-	constructor() {
-		super();
-	}
-
-	destroy() {
-		const staticAreaDomRef = document.querySelector(this.tagName.toLowerCase());
-		staticAreaDomRef.parentElement.removeChild(staticAreaDomRef);
-	}
+if (!customElements.get("ui5-static-area")) {
+	customElements.define("ui5-static-area", class extends HTMLElement {});
 }
-
-customElements.define("ui5-static-area", StaticAreaElement);
-
-export {
-	getStaticAreaInstance,
-	removeStaticArea,
-};

package/src/StaticAreaItem.js

@@ -1,49 +1,67 @@
-import { getStaticAreaInstance, removeStaticArea } from "./StaticArea.js";
+import "./StaticArea.js";
+import updateShadowRoot from "./updateShadowRoot.js";
+import { renderFinished } from "./Render.js";
+import getEffectiveContentDensity from "./util/getEffectiveContentDensity.js";
+import { getEffectiveScopingSuffixForTag } from "./CustomElementsScopeUtils.js";
+import getEffectiveDir from "./locale/getEffectiveDir.js";
 
 /**
+ *
  * @class
  * @author SAP SE
  * @private
- * Defines and takes care of ui5-static-are-item items
  */
-class StaticAreaItem {
-	constructor(_ui5ElementContext) {
-		this.ui5ElementContext = _ui5ElementContext;
+class StaticAreaItem extends HTMLElement {
+	constructor() {
+		super();
+		this._rendered = false;
+		this.attachShadow({ mode: "open" });
 	}
 
 	/**
 	 * @protected
+	 * @param ownerElement The UI5Element instance that owns this static area item
 	 */
-	_updateFragment() {
-		const renderResult = this.ui5ElementContext.constructor.staticAreaTemplate(this.ui5ElementContext),
-			stylesToAdd = this.ui5ElementContext.constructor.staticAreaStyles || false;
-
-		if (!this.staticAreaItemDomRef) {
-			// Initial rendering of fragment
-
-			this.staticAreaItemDomRef = document.createElement("ui5-static-area-item");
-			this.staticAreaItemDomRef.attachShadow({ mode: "open" });
-			this.staticAreaItemDomRef.classList.add(this.ui5ElementContext._id); // used for getting the popover in the tests
-
-			getStaticAreaInstance().appendChild(this.staticAreaItemDomRef);
+	setOwnerElement(ownerElement) {
+		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.ui5ElementContext.constructor.render(renderResult, this.staticAreaItemDomRef.shadowRoot, stylesToAdd, { eventContext: this.ui5ElementContext });
 	}
 
 	/**
+	 * Updates the shadow root of the static area item with the latest state, if rendered
 	 * @protected
 	 */
-	_removeFragmentFromStaticArea() {
-		const staticArea = getStaticAreaInstance();
-
-		staticArea.removeChild(this.staticAreaItemDomRef);
+	update() {
+		if (this._rendered) {
+			this._updateContentDensity();
+			this._updateDirection();
+			updateShadowRoot(this.ownerElement, true);
+		}
+	}
 
-		this.staticAreaItemDomRef = null;
+	/**
+	 * Sets the correct content density based on the owner element's state
+	 * @private
+	 */
+	_updateContentDensity() {
+		if (getEffectiveContentDensity(this.ownerElement) === "compact") {
+			this.classList.add("sapUiSizeCompact");
+			this.classList.add("ui5-content-density-compact");
+		} else {
+			this.classList.remove("sapUiSizeCompact");
+			this.classList.remove("ui5-content-density-compact");
+		}
+	}
 
-		// remove static area
-		if (staticArea.childElementCount < 1) {
-			removeStaticArea();
+	_updateDirection() {
+		const dir = getEffectiveDir(this.ownerElement);
+		if (dir) {
+			this.setAttribute("dir", dir);
+		} else {
+			this.removeAttribute("dir");
 		}
 	}
 
@@ -51,17 +69,33 @@ class StaticAreaItem {
 	 * @protected
 	 * Returns reference to the DOM element where the current fragment is added.
 	 */
-	getDomRef() {
-		return this.staticAreaItemDomRef.shadowRoot;
+	async getDomRef() {
+		this._updateContentDensity();
+		if (!this._rendered) {
+			this._rendered = true;
+			updateShadowRoot(this.ownerElement, true);
+		}
+		await renderFinished(); // Wait for the content of the ui5-static-area-item to be rendered
+		return this.shadowRoot;
 	}
-}
 
-class StaticAreaItemElement extends HTMLElement {
-	constructor() {
-		super();
+	static getTag() {
+		const pureTag = "ui5-static-area-item";
+		const suffix = getEffectiveScopingSuffixForTag(pureTag);
+		if (!suffix) {
+			return pureTag;
+		}
+
+		return `${pureTag}-${suffix}`;
 	}
-}
 
-customElements.define("ui5-static-area-item", StaticAreaItemElement);
+	static createInstance() {
+		if (!customElements.get(StaticAreaItem.getTag())) {
+			customElements.define(StaticAreaItem.getTag(), StaticAreaItem);
+		}
+
+		return document.createElement(this.getTag());
+	}
+}
 
 export default StaticAreaItem;

package/src/SystemCSSVars.js

@@ -0,0 +1,10 @@
+import { hasStyle, createStyle } from "./ManagedStyles.js";
+import systemCSSVars from "./generated/css/SystemCSSVars.css.js";
+
+const insertSystemCSSVars = () => {
+	if (!hasStyle("data-ui5-system-css-vars")) {
+		createStyle(systemCSSVars, "data-ui5-system-css-vars");
+	}
+};
+
+export default insertSystemCSSVars;

package/src/Theming.js

@@ -1,45 +1,4 @@
-import { addCustomCSS, getCustomCSS } from "./theming/CustomStyle.js";
-import { getThemeProperties, getRegisteredPackages } from "./asset-registries/Themes.js";
-import { injectThemeProperties } from "./theming/StyleInjection.js";
+import { addCustomCSS } from "./theming/CustomStyle.js";
+import { attachThemeLoaded, detachThemeLoaded } from "./theming/ThemeLoaded.js";
 
-const themeChangeCallbacks = [];
-
-const attachThemeChange = function attachThemeChange(callback) {
-	if (themeChangeCallbacks.indexOf(callback) === -1) {
-		themeChangeCallbacks.push(callback);
-	}
-};
-
-const _applyTheme = async theme => {
-	let cssText = "";
-
-	const registeredPackages = getRegisteredPackages();
-	registeredPackages.forEach(async packageName => {
-		cssText = await getThemeProperties(packageName, theme);
-		injectThemeProperties(cssText, packageName);
-	});
-
-	_executeThemeChangeCallbacks(theme);
-};
-
-const _executeThemeChangeCallbacks = theme => {
-	themeChangeCallbacks.forEach(callback => callback(theme));
-};
-
-const getEffectiveStyle = ElementClass => {
-	const tag = ElementClass.getMetadata().getTag();
-	const customStyle = getCustomCSS(tag) || "";
-	let componentStyles = ElementClass.styles;
-
-	if (Array.isArray(componentStyles)) {
-		componentStyles = componentStyles.join(" ");
-	}
-	return `${componentStyles} ${customStyle}`;
-};
-
-export {
-	attachThemeChange,
-	_applyTheme,
-	getEffectiveStyle,
-	addCustomCSS,
-};
+export { addCustomCSS, attachThemeLoaded, detachThemeLoaded };