@ui5/webcomponents-base 0.0.0-2db62badf → 0.0.0-2f7664755

package/src/CustomElementsRegistry.ts

@@ -0,0 +1,98 @@
+import getSharedResource from "./getSharedResource.js";
+import { getCurrentRuntimeIndex, compareRuntimes, getAllRuntimes } from "./Runtimes.js";
+import { Timeout } from "./types.js";
+
+const Tags = getSharedResource<Map<string, number>>("Tags", new Map());
+const Definitions = new Set<string>();
+
+let Failures = new Map<number, Set<string>>();
+let failureTimeout: Timeout | undefined;
+
+const UNKNOWN_RUNTIME = -1;
+
+const registerTag = (tag: string) => {
+	Definitions.add(tag);
+	Tags.set(tag, getCurrentRuntimeIndex());
+};
+
+const isTagRegistered = (tag: string) => {
+	return Definitions.has(tag);
+};
+
+const getAllRegisteredTags = () => {
+	return [...Definitions.values()];
+};
+
+const recordTagRegistrationFailure = (tag: string) => {
+	let tagRegRuntimeIndex = Tags.get(tag);
+	if (tagRegRuntimeIndex === undefined) {
+		tagRegRuntimeIndex = UNKNOWN_RUNTIME; // If the tag is taken, but not registered in Tags, then a version before 1.1.0 defined it => use the "unknown" key
+	}
+
+	if (!Failures.has(tagRegRuntimeIndex)) {
+		Failures.set(tagRegRuntimeIndex, new Set());
+	}
+	Failures.get(tagRegRuntimeIndex)!.add(tag);
+
+	if (!failureTimeout) {
+		failureTimeout = setTimeout(() => {
+			displayFailedRegistrations();
+			Failures = new Map();
+			failureTimeout = undefined;
+		}, 1000);
+	}
+};
+
+const displayFailedRegistrations = () => {
+	const allRuntimes = getAllRuntimes();
+	const currentRuntimeIndex = getCurrentRuntimeIndex();
+	const currentRuntime = allRuntimes[currentRuntimeIndex];
+
+	let message = `Multiple UI5 Web Components instances detected.`;
+
+	if (allRuntimes.length > 1) {
+		message = `${message}\nLoading order (versions before 1.1.0 not listed): ${allRuntimes.map(runtime => `\n${runtime.description}`).join("")}`;
+	}
+
+	[...Failures.keys()].forEach(otherRuntimeIndex => {
+		let comparison: number;
+		let otherRuntime;
+
+		if (otherRuntimeIndex === UNKNOWN_RUNTIME) { // version < 1.1.0 defined the tag
+			comparison = 1; // the current runtime is considered newer
+			otherRuntime = {
+				description: `Older unknown runtime`,
+			};
+		} else {
+			comparison = compareRuntimes(currentRuntimeIndex, otherRuntimeIndex);
+			otherRuntime = allRuntimes[otherRuntimeIndex];
+		}
+
+		let compareWord;
+		if (comparison > 0) {
+			compareWord = "an older";
+		} else if (comparison < 0) {
+			compareWord = "a newer";
+		} else {
+			compareWord = "the same";
+		}
+		message = `${message}\n\n"${currentRuntime.description}" failed to define ${Failures.get(otherRuntimeIndex)!.size} tag(s) as they were defined by a runtime of ${compareWord} version "${otherRuntime.description}": ${([...Failures.get(otherRuntimeIndex)!]).sort().join(", ")}.`;
+
+		if (comparison > 0) {
+			message = `${message}\nWARNING! If your code uses features of the above web components, unavailable in ${otherRuntime.description}, it might not work as expected!`;
+		} else {
+			message = `${message}\nSince the above web components were defined by the same or newer version runtime, they should be compatible with your code.`;
+		}
+	});
+
+	message = `${message}\n\nTo prevent other runtimes from defining tags that you use, consider using scoping or have third-party libraries use scoping: https://github.com/SAP/ui5-webcomponents/blob/main/docs/2-advanced/03-scoping.md.`;
+
+	console.warn(message); // eslint-disable-line
+};
+
+export {
+	registerTag,
+	isTagRegistered,
+	getAllRegisteredTags,
+	recordTagRegistrationFailure,
+};

package/src/CustomElementsScope.ts

@@ -0,0 +1,33 @@
+import {
+	html,
+	svg,
+	unsafeStatic,
+} from "lit-html/static.js";
+
+import {
+	setCustomElementsScopingSuffix,
+	getCustomElementsScopingSuffix,
+	setCustomElementsScopingRules,
+	getCustomElementsScopingRules,
+	shouldScopeCustomElement,
+	getEffectiveScopingSuffixForTag,
+} from "./CustomElementsScopeUtils.js";
+import { registerFeature } from "./FeaturesRegistry.js";
+
+class LitStatic {
+	static html = html;
+	static svg = svg;
+	static unsafeStatic: (value: string) => object = unsafeStatic;
+}
+
+registerFeature("LitStatic", LitStatic);
+
+export {
+	LitStatic,
+	setCustomElementsScopingSuffix,
+	getCustomElementsScopingSuffix,
+	setCustomElementsScopingRules,
+	getCustomElementsScopingRules,
+	shouldScopeCustomElement,
+	getEffectiveScopingSuffixForTag,
+};

package/src/CustomElementsScopeUtils.ts

@@ -0,0 +1,115 @@
+let suf: string;
+
+type Rules = {
+	include: Array<RegExp>,
+	exclude: Array<RegExp>,
+};
+
+let rulesObj: Rules = {
+	include: [/^ui5-/],
+	exclude: [],
+};
+
+const tagsCache = new Map<string, boolean>(); // true/false means the tag should/should not be cached, undefined means not known yet.
+
+/**
+ * Sets the suffix to be used for custom elements scoping, f.e. pass "demo" to get tags such as "ui5-button-demo".
+ * Note: by default all tags starting with "ui5-" will be scoped, unless you change this by calling "setCustomElementsScopingRules"
+ *
+ * @public
+ * @param suffix The scoping suffix
+ */
+const setCustomElementsScopingSuffix = (suffix: string) => {
+	if (!suffix.match(/^[a-zA-Z0-9_-]+$/)) {
+		throw new Error("Only alphanumeric characters and dashes allowed for the scoping suffix");
+	}
+
+	suf = suffix;
+};
+
+/**
+ * Returns the currently set scoping suffix, or undefined if not set.
+ *
+ * @public
+ * @returns {String|undefined}
+ */
+const getCustomElementsScopingSuffix = () => {
+	return suf;
+};
+
+/**
+ * Sets the rules, governing which custom element tags to scope and which not, f.e.
+ * setCustomElementsScopingRules({include: [/^ui5-/]}, exclude: [/^ui5-mylib-/, /^ui5-carousel$/]);
+ * will scope all elements starting with "ui5-" but not the ones starting with "ui5-mylib-" and not "ui5-carousel".
+ *
+ * @public
+ * @param rules Object with "include" and "exclude" properties, both arrays of regular expressions. Note that "include"
+ * rules are applied first and "exclude" rules second.
+ */
+const setCustomElementsScopingRules = (rules: Rules) => {
+	if (!rules || !rules.include) {
+		throw new Error(`"rules" must be an object with at least an "include" property`);
+	}
+
+	if (!Array.isArray(rules.include) || rules.include.some(rule => !(rule instanceof RegExp))) {
+		throw new Error(`"rules.include" must be an array of regular expressions`);
+	}
+
+	if (rules.exclude && (!Array.isArray(rules.exclude) || rules.exclude.some(rule => !(rule instanceof RegExp)))) {
+		throw new Error(`"rules.exclude" must be an array of regular expressions`);
+	}
+
+	rules.exclude = rules.exclude || [];
+	rulesObj = rules;
+	tagsCache.clear(); // reset the cache upon setting new rules
+};
+
+/**
+ * Returns the rules, governing which custom element tags to scope and which not. By default, all elements
+ * starting with "ui5-" are scoped. The default rules are: {include: [/^ui5-/]}.
+ *
+ * @public
+ * @returns {Object}
+ */
+const getCustomElementsScopingRules = () => {
+	return rulesObj;
+};
+
+/**
+ * Determines whether custom elements with the given tag should be scoped or not.
+ * The tag is first matched against the "include" rules and then against the "exclude" rules and the
+ * result is cached until new rules are set.
+ *
+ * @public
+ * @param tag
+ */
+const shouldScopeCustomElement = (tag: string) => {
+	if (!tagsCache.has(tag)) {
+		const result = rulesObj.include.some(rule => tag.match(rule)) && !rulesObj.exclude.some(rule => tag.match(rule));
+		tagsCache.set(tag, result);
+	}
+
+	return tagsCache.get(tag);
+};
+
+/**
+ * Returns the currently set scoping suffix, if any and if the tag should be scoped, or undefined otherwise.
+ *
+ * @public
+ * @param tag
+ * @returns {String}
+ */
+const getEffectiveScopingSuffixForTag = (tag: string) => {
+	if (shouldScopeCustomElement(tag)) {
+		return getCustomElementsScopingSuffix();
+	}
+};
+
+export {
+	setCustomElementsScopingSuffix,
+	getCustomElementsScopingSuffix,
+	setCustomElementsScopingRules,
+	getCustomElementsScopingRules,
+	shouldScopeCustomElement,
+	getEffectiveScopingSuffixForTag,
+};

package/src/DOMObserver.ts

@@ -0,0 +1,28 @@
+const observers = new WeakMap<Node, MutationObserver>();
+
+/**
+ * @param node
+ * @param callback
+ * @param options
+ */
+const observeDOMNode = (node: Node, callback: MutationCallback, options?: MutationObserverInit) => {
+	const observer = new MutationObserver(callback);
+	observers.set(node, observer);
+	observer.observe(node, options);
+};
+
+/**
+ * @param node
+ */
+const unobserveDOMNode = (node: Node) => {
+	const observer = observers.get(node);
+	if (observer) {
+		observer.disconnect();
+		observers.delete(node);
+	}
+};
+
+export {
+	observeDOMNode,
+	unobserveDOMNode,
+};

package/src/Device.ts

@@ -0,0 +1,124 @@
+const ua = navigator.userAgent;
+const touch = "ontouchstart" in window || navigator.maxTouchPoints > 0;
+const ie = /(msie|trident)/i.test(ua);
+const chrome = !ie && /(Chrome|CriOS)/.test(ua);
+const firefox = /Firefox/.test(ua);
+const safari = !ie && !chrome && /(Version|PhantomJS)\/(\d+\.\d+).*Safari/.test(ua);
+const webkit = !ie && /webkit/.test(ua);
+const windows = navigator.platform.indexOf("Win") !== -1;
+const iOS = !!(navigator.platform.match(/iPhone|iPad|iPod/)) || !!(navigator.userAgent.match(/Mac/) && "ontouchend" in document);
+const android = !windows && /Android/.test(ua);
+const androidPhone = android && /(?=android)(?=.*mobile)/i.test(ua);
+const ipad = /ipad/i.test(ua) || (/Macintosh/i.test(ua) && "ontouchend" in document);
+// With iOS 13 the string 'iPad' was removed from the user agent string through a browser setting, which is applied on all sites by default:
+// "Request Desktop Website -> All websites" (for more infos see: https://forums.developer.apple.com/thread/119186).
+// Therefore the OS is detected as MACINTOSH instead of iOS and the device is a tablet if the Device.support.touch is true.
+
+let windowsVersion: number;
+let webkitVersion: number;
+let tablet: boolean;
+
+const isWindows8OrAbove = () => {
+	if (!windows) {
+		return false;
+	}
+
+	if (windowsVersion === undefined) {
+		const matches = ua.match(/Windows NT (\d+).(\d)/);
+		windowsVersion = matches ? parseFloat(matches[1]) : 0;
+	}
+
+	return windowsVersion >= 8;
+};
+
+const isWebkit537OrAbove = () => {
+	if (!webkit) {
+		return false;
+	}
+
+	if (webkitVersion === undefined) {
+		const matches = ua.match(/(webkit)[ /]([\w.]+)/);
+		webkitVersion = matches ? parseFloat(matches[1]) : 0;
+	}
+
+	return webkitVersion >= 537.10;
+};
+
+const detectTablet = () => {
+	if (tablet !== undefined) {
+		return;
+	}
+
+	if (ipad) {
+		tablet = true;
+		return;
+	}
+
+	if (touch) {
+		if (isWindows8OrAbove()) {
+			tablet = true;
+			return;
+		}
+
+		if (chrome && android) {
+			tablet = !/Mobile Safari\/[.0-9]+/.test(ua);
+			return;
+		}
+
+		let densityFactor = window.devicePixelRatio ? window.devicePixelRatio : 1; // may be undefined in Windows Phone devices
+		if (android && isWebkit537OrAbove()) {
+			densityFactor = 1;
+		}
+
+		tablet = (Math.min(window.screen.width / densityFactor, window.screen.height / densityFactor) >= 600);
+		return;
+	}
+
+	tablet = (ie && ua.indexOf("Touch") !== -1) || (android && !androidPhone);
+};
+
+const supportsTouch = (): boolean => touch;
+const isIE = (): boolean => ie;
+const isSafari = (): boolean => safari;
+const isChrome = (): boolean => chrome;
+const isFirefox = (): boolean => firefox;
+
+const isTablet = (): boolean => {
+	detectTablet();
+	return (touch || isWindows8OrAbove()) && tablet;
+};
+
+const isPhone = (): boolean => {
+	detectTablet();
+	return touch && !tablet;
+};
+
+const isDesktop = (): boolean => {
+	return (!isTablet() && !isPhone()) || isWindows8OrAbove();
+};
+
+const isCombi = (): boolean => {
+	return isTablet() && isDesktop();
+};
+
+const isIOS = (): boolean => {
+	return iOS;
+};
+
+const isAndroid = (): boolean => {
+	return android || androidPhone;
+};
+
+export {
+	supportsTouch,
+	isIE,
+	isSafari,
+	isChrome,
+	isFirefox,
+	isPhone,
+	isTablet,
+	isDesktop,
+	isCombi,
+	isIOS,
+	isAndroid,
+};

package/src/EventProvider.ts

@@ -0,0 +1,87 @@
+class EventProvider<EventListenerParam, EventListenerReturn> {
+	_eventRegistry: Map<string, Array<(param: EventListenerParam) => EventListenerReturn>>;
+
+	constructor() {
+		this._eventRegistry = new Map();
+	}
+
+	attachEvent(eventName: string, fnFunction: (param: EventListenerParam) => EventListenerReturn) {
+		const eventRegistry = this._eventRegistry;
+		const eventListeners = eventRegistry.get(eventName);
+
+		if (!Array.isArray(eventListeners)) {
+			eventRegistry.set(eventName, [fnFunction]);
+			return;
+		}
+
+		if (!eventListeners.includes(fnFunction)) {
+			eventListeners.push(fnFunction);
+		}
+	}
+
+	detachEvent(eventName: string, fnFunction: (param: EventListenerParam) => EventListenerReturn) {
+		const eventRegistry = this._eventRegistry;
+		const eventListeners = eventRegistry.get(eventName);
+
+		if (!eventListeners) {
+			return;
+		}
+		const indexOfFnToDetach = eventListeners.indexOf(fnFunction);
+
+		if (indexOfFnToDetach !== -1) {
+			eventListeners.splice(indexOfFnToDetach, 1);
+		}
+
+		if (eventListeners.length === 0) {
+			eventRegistry.delete(eventName);
+		}
+	}
+
+	/**
+	 * Fires an event and returns the results of all event listeners as an array.
+	 *
+	 * @param eventName the event to fire
+	 * @param data optional data to pass to each event listener
+	 * @returns {Array} an array with the results of all event listeners
+	 */
+	fireEvent(eventName: string, data: EventListenerParam) {
+		const eventRegistry = this._eventRegistry;
+		const eventListeners = eventRegistry.get(eventName);
+
+		if (!eventListeners) {
+			return [];
+		}
+
+		return eventListeners.map(fn => {
+			return fn.call(this, data); // eslint-disable-line
+		});
+	}
+
+	/**
+	 * Fires an event and returns a promise that will resolve once all listeners have resolved.
+	 *
+	 * @param eventName the event to fire
+	 * @param data optional data to pass to each event listener
+	 * @returns {Promise} a promise that will resolve when all listeners have resolved
+	 */
+	fireEventAsync(eventName: string, data: EventListenerParam) {
+		return Promise.all(this.fireEvent(eventName, data));
+	}
+
+	isHandlerAttached(eventName: string, fnFunction: (param: EventListenerParam) => EventListenerReturn) {
+		const eventRegistry = this._eventRegistry;
+		const eventListeners = eventRegistry.get(eventName);
+
+		if (!eventListeners) {
+			return false;
+		}
+
+		return eventListeners.includes(fnFunction);
+	}
+
+	hasListeners(eventName: string) {
+		return !!this._eventRegistry.get(eventName);
+	}
+}
+
+export default EventProvider;

package/src/FeaturesRegistry.ts

@@ -0,0 +1,14 @@
+const features = new Map<string, any>();
+
+const registerFeature = (name: string, feature: object) => {
+	features.set(name, feature);
+};
+
+const getFeature = <T>(name: string): T => {
+	return features.get(name) as T;
+};
+
+export {
+	registerFeature,
+	getFeature,
+};

package/src/FontFace.ts

@@ -0,0 +1,31 @@
+import { hasStyle, createStyle } from "./ManagedStyles.js";
+import { getFeature } from "./FeaturesRegistry.js";
+import fontFaceCSS from "./generated/css/FontFace.css.js";
+import overrideFontFaceCSS from "./generated/css/OverrideFontFace.css.js";
+import type OpenUI5Support from "./features/OpenUI5Support.js";
+
+const insertFontFace = () => {
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
+
+	// Only set the main font if there is no OpenUI5 support, or there is, but OpenUI5 is not loaded
+	if (!openUI5Support || !openUI5Support.isLoaded()) {
+		insertMainFontFace();
+	}
+
+	// Always set the override font - OpenUI5 in CSS Vars mode does not set it, unlike the main font
+	insertOverrideFontFace();
+};
+
+const insertMainFontFace = () => {
+	if (!hasStyle("data-ui5-font-face")) {
+		createStyle(fontFaceCSS, "data-ui5-font-face");
+	}
+};
+
+const insertOverrideFontFace = () => {
+	if (!hasStyle("data-ui5-font-face-override")) {
+		createStyle(overrideFontFaceCSS, "data-ui5-font-face-override");
+	}
+};
+
+export default insertFontFace;