@ui5/webcomponents-base 0.0.0-1929d08ff → 0.0.0-1acdb5da5

package/src/ManagedStyles.js

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

package/src/MediaRange.js

@@ -1,109 +0,0 @@
-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/src/PropertiesFileFormat.js

@@ -1,95 +0,0 @@
-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/src/Render.js

@@ -1,175 +0,0 @@
-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/src/RenderQueue.js

@@ -1,66 +0,0 @@
-const MAX_PROCESS_COUNT = 10;
-
-class RenderQueue {
-	constructor() {
-		this.list = []; // Used to store the web components in order
-		this.lookup = new Set(); // Used for faster search
-	}
-
-	add(webComponent) {
-		if (this.lookup.has(webComponent)) {
-			return;
-		}
-
-		this.list.push(webComponent);
-		this.lookup.add(webComponent);
-	}
-
-	remove(webComponent) {
-		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) {
-		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();
-		}
-	}
-}
-
-export default RenderQueue;

package/src/RenderScheduler.js

@@ -1,44 +0,0 @@
-import {
-	renderDeferred,
-	renderImmediately,
-	renderFinished,
-} from "./Render.js";
-
-/**
- * @deprecated Use the Render.js module instead
- */
-class RenderScheduler {
-	/**
-	 * 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 async renderDeferred(webComponent) {
-		console.log("RenderScheduler.renderDeferred is deprecated, please use renderDeferred, exported by Render.js instead"); // eslint-disable-line
-		await renderDeferred(webComponent);
-	}
-
-	/**
-	 * Renders a component synchronously
-	 *
-	 * @param webComponent
-	 * @deprecated Use renderImmediately from the Render.js module instead
-	 */
-	static renderImmediately(webComponent) {
-		console.log("RenderScheduler.renderImmediately is deprecated, please use renderImmediately, exported by Render.js instead"); // eslint-disable-line
-		return renderImmediately(webComponent);
-	}
-
-	/**
-	 * @deprecated Use renderFinished from the Render.js module instead
-	 * @returns {Promise<void>}
-	 */
-	static async whenFinished() {
-		console.log("RenderScheduler.whenFinished is deprecated, please use renderFinished, exported by Render.js instead"); // eslint-disable-line
-		await renderFinished();
-	}
-}
-
-export default RenderScheduler;

package/src/Runtimes.js

@@ -1,107 +0,0 @@
-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,3 +0,0 @@
-if (!customElements.get("ui5-static-area")) {
-	customElements.define("ui5-static-area", class extends HTMLElement {});
-}