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

package/src/MediaRange.ts

@@ -0,0 +1,110 @@
+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.
+ *
+ * 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 {Range} [range] The given range set.
+ * @name MediaRange.initRangeSet
+ */
+const initRangeSet = (name: string, range: Range) => {
+	mediaRanges.set(name, range);
+};
+
+/**
+ * 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 {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: string, width = window.innerWidth): string => {
+	let rangeSet = mediaRanges.get(name);
+
+	if (!rangeSet) {
+		rangeSet = mediaRanges.get(RANGESETS.RANGE_4STEPS)!;
+	}
+
+	let currentRangeName;
+	const effectiveWidth = Math.floor(width);
+
+	rangeSet.forEach((value, key) => {
+		if (effectiveWidth >= value[0] && effectiveWidth <= value[1]) {
+			currentRangeName = key;
+		}
+	});
+
+	return currentRangeName || [...rangeSet.keys()][0];
+};
+
+/**
+ * API for screen width changes.
+ *
+ * @namespace
+ * @name MediaRange
+ */
+
+const MediaRange = {
+	RANGESETS,
+	initRangeSet,
+	getCurrentRange,
+};
+
+MediaRange.initRangeSet(MediaRange.RANGESETS.RANGE_4STEPS, DEAFULT_RANGE_SET);
+
+export default MediaRange;

package/src/PropertiesFileFormat.ts

@@ -0,0 +1,95 @@
+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: 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;
+const rEscapes = /(\\u[0-9a-fA-F]{0,4})|(\\.)|(\\$)/g;
+const mEscapes = {
+	"\\f": "\f",
+	"\\n": "\n",
+	"\\r": "\r",
+	"\\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: string) => {
+	const properties = {},
+		aLines = sText.split(rLines);
+
+	let sLine,
+		rMatcher,
+		sKey,
+		sValue: string,
+		i,
+		m,
+		iLastIndex,
+		iConcatOps: number;
+
+	const append = (s: string) => {
+		if (sValue) {
+			sValue = `${sValue}${s}`;
+			iConcatOps++;
+		} else {
+			sValue = s;
+			iConcatOps = 0;
+		}
+	};
+
+	for (i = 0; i < aLines.length; i++) {
+		sLine = aLines[i];
+		const skipLine = sLine === "" || sLine.charAt(0) === "#" || sLine.charAt(0) === "!";
+
+		if (!skipLine) {
+			rMatcher = rEscapesOrSeparator;
+			iLastIndex = 0;
+			rMatcher.lastIndex = iLastIndex;
+			sKey = null;
+			sValue = "";
+			m = rMatcher.exec(sLine);
+			while (m !== null) {
+				if (iLastIndex < m.index) {
+					append(sLine.slice(iLastIndex, m.index));
+				}
+				iLastIndex = rMatcher.lastIndex;
+				if (m[1]) {
+					if (m[1].length !== 6) {
+						throw new Error(`Incomplete Unicode Escape '${m[1]}'`);
+					}
+					append(String.fromCharCode(parseInt(m[1].slice(2), 16)));
+				} else if (m[2]) {
+					append(mEscapes[m[2] as keyof typeof mEscapes] || m[2].slice(1));
+				} else if (m[3]) {
+					sLine = aLines[++i];
+					iLastIndex = 0;
+					rMatcher.lastIndex = iLastIndex;
+				} else if (m[4]) {
+					sKey = sValue;
+					sValue = "";
+					rMatcher = rEscapes;
+					rMatcher.lastIndex = iLastIndex;
+				}
+				m = rMatcher.exec(sLine);
+			}
+			if (iLastIndex < sLine.length) {
+				append(sLine.slice(iLastIndex));
+			}
+			if (sKey == null) {
+				sKey = sValue;
+				sValue = "";
+			}
+			(properties as Record<string, any>)[sKey] = flatstr(sValue, sValue ? iConcatOps! : 0);
+		}
+	}
+	return properties;
+};
+
+export default parseProperties;

package/src/Render.ts

@@ -0,0 +1,180 @@
+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";
+
+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: Promise<void> | undefined,
+	renderTaskPromiseResolve: PromiseResolve | undefined;
+
+let mutationObserverTimer: Timeout | undefined;
+
+let queuePromise: Promise<void> | null;
+
+/**
+ * Schedules a render task (if not already scheduled) to render the component
+ *
+ * @param webComponent
+ * @returns {Promise}
+ */
+const renderDeferred = async (webComponent: UI5Element) => {
+	// 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: UI5Element) => {
+	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: UI5Element) => {
+	invalidatedWebComponents.remove(webComponent);
+	registeredElements.delete(webComponent);
+};
+
+/**
+ * Schedules a rendering task, if not scheduled already
+ */
+const scheduleRenderTask = async () => {
+	if (!queuePromise) {
+		queuePromise = new Promise<void>(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<void>(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({themeAware: true}) -> re-renders only themeAware 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?: {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);
+		}
+	});
+	await renderFinished();
+};
+
+const attachBeforeComponentRender = (listener: BeforeComponentRenderCallback) => {
+	eventProvider.attachEvent("beforeComponentRender", listener);
+};
+
+const detachBeforeComponentRender = (listener: BeforeComponentRenderCallback) => {
+	eventProvider.detachEvent("beforeComponentRender", listener);
+};
+
+export {
+	renderDeferred,
+	renderImmediately,
+	cancelRender,
+	renderFinished,
+	reRenderAllUI5Elements,
+	attachBeforeComponentRender,
+	detachBeforeComponentRender,
+};

package/src/RenderQueue.ts

@@ -0,0 +1,71 @@
+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: UI5Element) {
+		if (this.lookup.has(webComponent)) {
+			return;
+		}
+
+		this.list.push(webComponent);
+		this.lookup.add(webComponent);
+	}
+
+	remove(webComponent: UI5Element) {
+		if (!this.lookup.has(webComponent)) {
+			return;
+		}
+
+		this.list = this.list.filter(item => item !== webComponent);
+		this.lookup.delete(webComponent);
+	}
+
+	shift() {
+		const webComponent = this.list.shift();
+		if (webComponent) {
+			this.lookup.delete(webComponent);
+			return webComponent;
+		}
+	}
+
+	isEmpty() {
+		return this.list.length === 0;
+	}
+
+	isAdded(webComponent: UI5Element) {
+		return this.lookup.has(webComponent);
+	}
+
+	/**
+	 * Processes the whole queue by executing the callback on each component,
+	 * while also imposing restrictions on how many times a component may be processed.
+	 *
+	 * @param callback - function with one argument (the web component to be processed)
+	 */
+	process(callback: (el: UI5Element) => void) {
+		let webComponent;
+		const stats = new Map<UI5Element, number>();
+
+		webComponent = this.shift();
+		while (webComponent) {
+			const timesProcessed = stats.get(webComponent) || 0;
+			if (timesProcessed > MAX_PROCESS_COUNT) {
+				throw new Error(`Web component processed too many times this task, max allowed is: ${MAX_PROCESS_COUNT}`);
+			}
+			callback(webComponent);
+			stats.set(webComponent, timesProcessed + 1);
+			webComponent = this.shift();
+		}
+	}
+}
+
+export default RenderQueue;

package/src/Runtimes.ts

@@ -0,0 +1,114 @@
+import VersionInfo from "./generated/VersionInfo.js";
+import getSharedResource from "./getSharedResource.js";
+
+type RuntimeData = VersionInfo & {
+	alias: string,
+	description: string,
+};
+
+let currentRuntimeIndex: number;
+let currentRuntimeAlias = "";
+
+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<Array<RuntimeData>>("Runtimes", []);
+
+/**
+ * Registers the current runtime in the shared runtimes resource registry
+ */
+const registerCurrentRuntime = () => {
+	if (currentRuntimeIndex === undefined) {
+		currentRuntimeIndex = Runtimes.length;
+		const versionInfo = VersionInfo;
+
+		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: number, index2: number) => {
+	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: string) => {
+	currentRuntimeAlias = alias;
+};
+
+const getAllRuntimes = () => {
+	return Runtimes;
+};
+
+export {
+	getCurrentRuntimeIndex,
+	registerCurrentRuntime,
+	compareRuntimes,
+	setRuntimeAlias,
+	getAllRuntimes,
+};

package/src/StaticArea.ts

@@ -0,0 +1,3 @@
+if (!customElements.get("ui5-static-area")) {
+	customElements.define("ui5-static-area", class extends HTMLElement {});
+}

package/src/StaticAreaItem.ts

@@ -0,0 +1,113 @@
+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";
+import type UI5Element from "./UI5Element.js";
+
+const pureTagName = "ui5-static-area-item";
+const popupIntegrationAttr = "data-sap-ui-integration-popup-content";
+
+/**
+ *
+ * @class
+ * @author SAP SE
+ * @private
+ */
+class StaticAreaItem extends HTMLElement {
+	_rendered: boolean;
+	ownerElement?: UI5Element;
+
+	constructor() {
+		super();
+		this._rendered = false;
+		this.attachShadow({ mode: "open" });
+	}
+
+	/**
+	 * @param {UI5Element} ownerElement the UI5Element instance that owns this static area item
+	 */
+	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
+		}
+	}
+
+	/**
+	 * Updates the shadow root of the static area item with the latest state, if rendered
+	 */
+	update() {
+		if (this._rendered) {
+			this._updateAdditionalAttrs();
+			this._updateContentDensity();
+			this._updateDirection();
+			updateShadowRoot(this.ownerElement!, true);
+		}
+	}
+
+	/**
+	 * 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");
+		}
+	}
+
+	_updateDirection() {
+		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.
+	 */
+	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;
+	}
+
+	static getTag() {
+		const suffix = getEffectiveScopingSuffixForTag(pureTagName);
+		if (!suffix) {
+			return pureTagName;
+		}
+
+		return `${pureTagName}-${suffix}`;
+	}
+
+	static createInstance() {
+		if (!customElements.get(StaticAreaItem.getTag())) {
+			customElements.define(StaticAreaItem.getTag(), StaticAreaItem);
+		}
+
+		return document.createElement(this.getTag()) as StaticAreaItem;
+	}
+}
+
+export default StaticAreaItem;

package/src/SystemCSSVars.ts

@@ -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.ts

@@ -0,0 +1,4 @@
+import { addCustomCSS } from "./theming/CustomStyle.js";
+import { attachThemeLoaded, detachThemeLoaded } from "./theming/ThemeLoaded.js";
+
+export { addCustomCSS, attachThemeLoaded, detachThemeLoaded };