@ui5/webcomponents-base 0.0.0-934b4df24 → 0.0.0-9c26e8e4f

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/dist/PropertiesFileFormat.js

@@ -0,0 +1,95 @@
+const flatstr = typeof chrome === "object" || typeof v8 === "object" ? (s, iConcatOps) => {
+	if (iConcatOps > 2 && 40 * iConcatOps > s.length) {
+		Number(s);
+	}
+	return s;
+} : s => 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 => {
+	const properties = {},
+		aLines = sText.split(rLines);
+
+	let sLine,
+		rMatcher,
+		sKey,
+		sValue,
+		i,
+		m,
+		iLastIndex,
+		iConcatOps;
+
+	const append = s => {
+		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]] || 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[sKey] = flatstr(sValue, sValue ? iConcatOps : 0);
+		}
+	}
+	return properties;
+};
+
+export default parseProperties;

package/dist/Render.js

@@ -0,0 +1,175 @@
+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({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 => {
+	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();
+		if (!filters || (filters.tag === tag) || (filters.rtlAware && rtlAware) || (filters.languageAware && languageAware) || (filters.themeAware && themeAware)) {
+			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,
+};

package/dist/RenderQueue.js

@@ -1,41 +1,65 @@
+const MAX_PROCESS_COUNT = 10;
+
 class RenderQueue {
 	constructor() {
 		this.list = []; // Used to store the web components in order
-		this.promises = new Map(); // Used to store promises for web component rendering
+		this.lookup = new Set(); // Used for faster search
 	}
 
 	add(webComponent) {
-		if (this.promises.has(webComponent)) {
-			return this.promises.get(webComponent);
+		if (this.lookup.has(webComponent)) {
+			return;
 		}
 
-		let deferredResolve;
-		const promise = new Promise(resolve => {
-			deferredResolve = resolve;
-		});
-		promise._deferredResolve = deferredResolve;
-
 		this.list.push(webComponent);
-		this.promises.set(webComponent, promise);
+		this.lookup.add(webComponent);
+	}
+
+	remove(webComponent) {
+		if (!this.lookup.has(webComponent)) {
+			return;
+		}
 
-		return promise;
+		this.list = this.list.filter(item => item !== webComponent);
+		this.lookup.delete(webComponent);
 	}
 
 	shift() {
 		const webComponent = this.list.shift();
 		if (webComponent) {
-			const promise = this.promises.get(webComponent);
-			this.promises.delete(webComponent);
-			return { webComponent, promise };
+			this.lookup.delete(webComponent);
+			return webComponent;
 		}
 	}
 
-	getList() {
-		return this.list;
+	isEmpty() {
+		return this.list.length === 0;
 	}
 
 	isAdded(webComponent) {
-		return this.promises.has(webComponent);
+		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) {
+		let webComponent;
+		const stats = new Map();
+
+		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();
+		}
 	}
 }
 

package/dist/RenderScheduler.js

@@ -1,145 +1,43 @@
-import RenderQueue from "./RenderQueue.js";
-import { getAllRegisteredTags } from "./CustomElementsRegistry.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;
+	static async renderDeferred(webComponent) {
+		console.log("RenderScheduler.renderDeferred is deprecated, please use renderDeferred, exported by Render.js instead"); // eslint-disable-line
+		await renderDeferred(webComponent);
 	}
 
 	/**
-	 * Schedules a rendering task, if not scheduled already
+	 * Renders a component synchronously
+	 *
+	 * @param webComponent
+	 * @deprecated Use renderImmediately from the Render.js module instead
 	 */
-	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 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 invalidated web components are rendered
+	 * @deprecated Use renderFinished from the Render.js module instead
+	 * @returns {Promise<void>}
 	 */
-	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 whenAllCustomElementsAreDefined() {
-		const definedPromises = getAllRegisteredTags().map(tag => customElements.whenDefined(tag));
-		return Promise.all(definedPromises);
-	}
-
 	static async whenFinished() {
-		await RenderScheduler.whenAllCustomElementsAreDefined();
-		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();
 	}
 }