@ui5/webcomponents-base 0.0.0-c6155714e → 0.0.0-c638668a1

package/src/delegate/ScrollEnablement.js

@@ -1,13 +1,37 @@
+import { supportsTouch } from "../Device.js";
 import EventProvider from "../EventProvider.js";
 import scroll from "../animations/scroll.js";
 
 const scrollEventName = "scroll";
+const touchEndEventName = supportsTouch() ? "touchend" : "mouseup";
 
 class ScrollEnablement extends EventProvider {
 	constructor(containerComponent) {
 		super();
-		containerComponent.addEventListener("touchstart", this.ontouchstart.bind(this), { passive: true });
-		containerComponent.addEventListener("touchmove", this.ontouchmove.bind(this), { passive: true });
+		this.containerComponent = containerComponent;
+		this.mouseMove = this.ontouchmove.bind(this);
+		this.mouseUp = this.ontouchend.bind(this);
+		this.touchStart = this.ontouchstart.bind(this);
+
+		this.supportsTouch = supportsTouch();
+
+		// On Android devices touchmove is thrown one more time than neccessary (together with touchend)
+		// so we have to cache the previus coordinates in order to provide correct parameters in the
+		// event for Android
+		this.cachedValue = {};
+
+		// In components like Carousel you need to know if the user has clicked on something or swiped
+		// in order to throw the needed event or not
+		this.startX = 0;
+		this.startY = 0;
+
+		if (this.supportsTouch) {
+			containerComponent.addEventListener("touchstart", this.touchStart, { passive: true });
+			containerComponent.addEventListener("touchmove", this.mouseMove, { passive: true });
+			containerComponent.addEventListener("touchend", this.mouseUp, { passive: true });
+		} else {
+			containerComponent.addEventListener("mousedown", this.touchStart, { passive: true });
+		}
 	}
 
 	set scrollContainer(container) {
@@ -18,12 +42,41 @@ class ScrollEnablement extends EventProvider {
 		return this._container;
 	}
 
-	scrollTo(left, top) {
+	/**
+	 * Scrolls the container to the left/top position, retrying retryCount times, if the container is not yet painted
+	 *
+	 * @param left
+	 * @param top
+	 * @param retryCount
+	 * @param retryInterval
+	 * @returns {Promise<void>} resolved when scrolled successfully
+	 */
+	async scrollTo(left, top, retryCount = 0, retryInterval = 0) {
+		let containerPainted = this.scrollContainer.clientHeight > 0 && this.scrollContainer.clientWidth > 0;
+
+		/* eslint-disable no-loop-func, no-await-in-loop */
+		while (!containerPainted && retryCount > 0) {
+			await new Promise(resolve => {
+				setTimeout(() => {
+					containerPainted = this.scrollContainer.clientHeight > 0 && this.scrollContainer.clientWidth > 0;
+					retryCount--;
+					resolve();
+				}, retryInterval);
+			});
+		}
+		/* eslint-disable no-loop-func, no-await-in-loop */
+
 		this._container.scrollLeft = left;
 		this._container.scrollTop = top;
 	}
 
-	move(dx, dy) {
+	move(dx, dy, disableAnimation) {
+		if (disableAnimation) {
+			this._container.scrollLeft += dx;
+			this._container.scrollTop += dy;
+			return;
+		}
+
 		return scroll({
 			element: this._container,
 			dx,
@@ -41,19 +94,29 @@ class ScrollEnablement extends EventProvider {
 
 	_isTouchInside(touch) {
 		const rect = this._container.getBoundingClientRect();
-		const x = touch.clientX;
-		const y = touch.clientY;
+		const x = this.supportsTouch ? touch.clientX : touch.x;
+		const y = this.supportsTouch ? touch.clientY : touch.y;
 
 		return x >= rect.left && x <= rect.right
 			&& y >= rect.top && y <= rect.bottom;
 	}
 
 	ontouchstart(event) {
-		const touch = event.touches[0];
-		this._prevDragX = touch.pageX;
-		this._prevDragY = touch.pageY;
+		const touch = this.supportsTouch ? event.touches[0] : null;
+
+		if (!this.supportsTouch) {
+			document.addEventListener("mouseup", this.mouseUp, { passive: true });
+			document.addEventListener("mousemove", this.mouseMove, { passive: true });
+		} else {
+			// Needed only on mobile
+			this.startX = touch.pageX;
+			this.startY = touch.pageY;
+		}
+
+		this._prevDragX = this.supportsTouch ? touch.pageX : event.x;
+		this._prevDragY = this.supportsTouch ? touch.pageY : event.y;
 
-		this._canScroll = this._isTouchInside(touch);
+		this._canScroll = this._isTouchInside(this.supportsTouch ? touch : event);
 	}
 
 	ontouchmove(event) {
@@ -62,19 +125,64 @@ class ScrollEnablement extends EventProvider {
 		}
 
 		const container = this._container;
-		const touch = event.touches[0];
+		const touch = this.supportsTouch ? event.touches[0] : null;
 
-		const dragX = touch.pageX;
-		const dragY = touch.pageY;
+		const dragX = this.supportsTouch ? touch.pageX : event.x;
+		const dragY = this.supportsTouch ? touch.pageY : event.y;
 
 		container.scrollLeft += this._prevDragX - dragX;
 		container.scrollTop += this._prevDragY - dragY;
 
-		this.fireEvent(scrollEventName, {});
+		this.fireEvent(scrollEventName, {
+			isLeft: dragX > this._prevDragX,
+			isRight: dragX < this._prevDragX,
+		});
+
+		this.cachedValue.dragX = this._prevDragX;
+		this.cachedValue.dragY = this._prevDragY;
 
 		this._prevDragX = dragX;
 		this._prevDragY = dragY;
 	}
+
+	ontouchend(event) {
+		if (this.supportsTouch) {
+			const deltaX = Math.abs(event.changedTouches[0].pageX - this.startX);
+			const deltaY = Math.abs(event.changedTouches[0].pageY - this.startY);
+
+			if (deltaX < 10 && deltaY < 10) {
+				return;
+			}
+		}
+
+		if (!this._canScroll) {
+			return;
+		}
+
+		const container = this._container;
+		const dragX = this.supportsTouch ? event.changedTouches[0].pageX : event.x;
+		const dragY = this.supportsTouch ? event.changedTouches[0].pageY : event.y;
+
+		container.scrollLeft += this._prevDragX - dragX;
+		container.scrollTop += this._prevDragY - dragY;
+
+		const useCachedValues = dragX === this._prevDragX;
+		const _dragX = useCachedValues ? this.cachedValue.dragX : dragX;
+		// const _dragY = useCachedValues ? this.cachedValue.dragY : dragY; add if needed
+
+		this.fireEvent(touchEndEventName, {
+			isLeft: _dragX < this._prevDragX,
+			isRight: _dragX > this._prevDragX,
+		});
+
+		this._prevDragX = dragX;
+		this._prevDragY = dragY;
+
+		if (!this.supportsTouch) {
+			document.removeEventListener("mousemove", this.mouseMove, { passive: true });
+			document.removeEventListener("mouseup", this.mouseUp);
+		}
+	}
 }
 
 export default ScrollEnablement;

package/src/features/F6Navigation.js

@@ -0,0 +1,106 @@
+import { registerFeature } from "../FeaturesRegistry.js";
+import { isF6Next, isF6Previous } from "../Keys.js";
+import { getFirstFocusableElement } from "../util/FocusableElements.js";
+
+class F6Navigation {
+	init() {
+		this.keydownHandler = this._keydownHandler.bind(this);
+		this.attachEventListeners();
+		this.selectedGroup = null;
+		this.groups = [];
+	}
+
+	attachEventListeners() {
+		document.addEventListener("keydown", this.keydownHandler);
+	}
+
+	async _keydownHandler(event) {
+		if (isF6Next(event)) {
+			this.updateGroups();
+			if (this.groups.length < 1) {
+				return;
+			}
+
+			const nextIndex = this.groups.indexOf(this.selectedGroup);
+			let nextElement = null;
+
+			if (nextIndex > -1) {
+				if (nextIndex + 1 >= this.groups.length) {
+					nextElement = this.groups[0];
+				} else {
+					nextElement = this.groups[nextIndex + 1];
+				}
+			} else {
+				nextElement = this.groups[0];
+			}
+
+			const elementToFocus = await getFirstFocusableElement(nextElement.isUI5Element ? nextElement.getDomRef() : nextElement, true);
+			elementToFocus.focus();
+		}
+
+		if (isF6Previous(event)) {
+			this.updateGroups();
+			if (this.groups.length < 1) {
+				return;
+			}
+
+			const nextIndex = this.groups.indexOf(this.selectedGroup);
+			let nextElement = null;
+
+			if (nextIndex > -1) {
+				if (nextIndex - 1 < 0) {
+					nextElement = this.groups[this.groups.length - 1];
+				} else {
+					// Handle the situation where the first focusable element of two neighbor groups is the same
+					// For example:
+					// <ui5-flexible-column-layout>
+					//     <ui5-list>
+					//         <ui5-li>List Item</ui5-li>
+					//     </ui5-list>
+					// </ui5-flexible-column-layout>
+					// Here for both FCL & List the firstFoccusableElement is the same (the ui5-li)
+
+					const firstFocusable = await getFirstFocusableElement(this.groups[nextIndex - 1], true);
+					const shouldSkipParent = firstFocusable === await getFirstFocusableElement(this.groups[nextIndex], true);
+
+					nextElement = this.groups[shouldSkipParent ? nextIndex - 2 : nextIndex - 1];
+				}
+			} else {
+				nextElement = this.groups[this.groups.length - 1];
+			}
+
+			const elementToFocus = await getFirstFocusableElement(nextElement.isUI5Element ? nextElement.getDomRef() : nextElement, true);
+			elementToFocus.focus();
+		}
+	}
+
+	removeEventListeners() {
+		document.removeEventListener("keydown", this.keydownHandler);
+	}
+
+	updateGroups() {
+		this.setSelectedGroup(document.activeElement);
+		this.setGroups();
+	}
+
+	setGroups() {
+		this.groups = Array.from(document.querySelectorAll("[data-sap-ui-fastnavgroup='true']")).filter(group => group.clientWidth && window.getComputedStyle(group).visibility !== "hidden");
+	}
+
+	setSelectedGroup(element) {
+		while (element && element.getAttribute("data-sap-ui-fastnavgroup") !== "true" && element !== document.querySelector("html")) {
+			element = element.parentElement ? element.parentNode : element.parentNode.host;
+		}
+
+		this.selectedGroup = element;
+	}
+
+	destroy() {
+		this.removeEventListeners();
+	}
+}
+
+const F6HelperInstance = new F6Navigation();
+registerFeature("F6Navigation", F6HelperInstance);
+
+export default F6Navigation;

package/src/features/OpenUI5Support.js

@@ -0,0 +1,125 @@
+import { registerFeature } from "../FeaturesRegistry.js";
+import { setTheme } from "../config/Theme.js";
+import { getCurrentZIndex } from "../util/PopupUtils.js";
+
+const getCore = () => {
+	const sap = window.sap;
+	const core = sap && sap.ui && typeof sap.ui.getCore === "function" && sap.ui.getCore();
+	return core;
+};
+
+const isLoaded = () => {
+	return !!getCore();
+};
+
+const init = () => {
+	const core = getCore();
+	if (!core) {
+		return Promise.resolve();
+	}
+
+	return new Promise(resolve => {
+		core.attachInit(() => {
+			window.sap.ui.require(["sap/ui/core/LocaleData", "sap/ui/core/Popup"], (LocaleData, Popup) => {
+				Popup.setInitialZIndex(getCurrentZIndex());
+				resolve();
+			});
+		});
+	});
+};
+
+const getConfigurationSettingsObject = () => {
+	const core = getCore();
+	if (!core) {
+		return;
+	}
+
+	const config = core.getConfiguration();
+	const LocaleData = window.sap.ui.require("sap/ui/core/LocaleData");
+
+	return {
+		animationMode: config.getAnimationMode(),
+		language: config.getLanguage(),
+		theme: config.getTheme(),
+		rtl: config.getRTL(),
+		calendarType: config.getCalendarType(),
+		formatSettings: {
+			firstDayOfWeek: LocaleData ? LocaleData.getInstance(config.getLocale()).getFirstDayOfWeek() : undefined,
+		},
+	};
+};
+
+const getLocaleDataObject = () => {
+	const core = getCore();
+	if (!core) {
+		return;
+	}
+
+	const config = core.getConfiguration();
+	const LocaleData = window.sap.ui.require("sap/ui/core/LocaleData");
+	return LocaleData.getInstance(config.getLocale())._get();
+};
+
+const listenForThemeChange = () => {
+	const core = getCore();
+	const config = core.getConfiguration();
+	core.attachThemeChanged(async () => {
+		await setTheme(config.getTheme());
+	});
+};
+
+const attachListeners = () => {
+	const core = getCore();
+	if (!core) {
+		return;
+	}
+
+	listenForThemeChange();
+};
+
+const cssVariablesLoaded = () => {
+	const core = getCore();
+	if (!core) {
+		return;
+	}
+
+	const link = [...document.head.children].find(el => el.id === "sap-ui-theme-sap.ui.core"); // more reliable than querySelector early
+	if (!link) {
+		return;
+	}
+
+	return !!link.href.match(/\/css(-|_)variables\.css/);
+};
+
+const getNextZIndex = () => {
+	const core = getCore();
+	if (!core) {
+		return;
+	}
+
+	const Popup = window.sap.ui.require("sap/ui/core/Popup");
+	return Popup.getNextZIndex();
+};
+
+const setInitialZIndex = () => {
+	const core = getCore();
+	if (!core) {
+		return;
+	}
+
+	const Popup = window.sap.ui.require("sap/ui/core/Popup");
+	Popup.setInitialZIndex(getCurrentZIndex());
+};
+
+const OpenUI5Support = {
+	isLoaded,
+	init,
+	getConfigurationSettingsObject,
+	getLocaleDataObject,
+	attachListeners,
+	cssVariablesLoaded,
+	getNextZIndex,
+	setInitialZIndex,
+};
+
+registerFeature("OpenUI5Support", OpenUI5Support);

package/src/getSharedResource.js

@@ -0,0 +1,30 @@
+import getSingletonElementInstance from "./util/getSingletonElementInstance.js";
+
+const getSharedResourcesInstance = () => getSingletonElementInstance("ui5-shared-resources", document.head);
+
+/**
+ * Use this method to initialize/get resources that you would like to be shared among UI5 Web Components runtime instances.
+ * The data will be accessed via a singleton "ui5-shared-resources" HTML element in the "head" element of the page.
+ *
+ * @public
+ * @param namespace Unique ID of the resource, may contain "." to denote hierarchy
+ * @param initialValue Object or primitive that will be used as an initial value if the resource does not exist
+ * @returns {*}
+ */
+const getSharedResource = (namespace, initialValue) => {
+	const parts = namespace.split(".");
+	let current = getSharedResourcesInstance();
+
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		const lastPart = i === parts.length - 1;
+		if (!Object.prototype.hasOwnProperty.call(current, part)) {
+			current[part] = lastPart ? initialValue : {};
+		}
+		current = current[part];
+	}
+
+	return current;
+};
+
+export default getSharedResource;

package/src/i18nBundle.js

@@ -1,35 +1,86 @@
-import { fetchI18nBundle, getI18nBundleData } from "./asset-registries/i18n.js";
+import { registerI18nLoader, fetchI18nBundle, getI18nBundleData } from "./asset-registries/i18n.js";
 import formatMessage from "./util/formatMessage.js";
 
 const I18nBundleInstances = new Map();
 
+let customGetI18nBundle;
+
+/**
+ * @class
+ * @public
+ */
 class I18nBundle {
 	constructor(packageName) {
 		this.packageName = packageName;
 	}
 
+	/**
+	 * Returns a text in the currently loaded language
+	 *
+	 * @public
+	 * @param {Object|String} textObj key/defaultText pair or just the key
+	 * @param params Values for the placeholders
+	 * @returns {*}
+	 */
 	getText(textObj, ...params) {
-		if (!textObj || !textObj.key || !textObj.defaultText) {
+		if (typeof textObj === "string") {
+			textObj = { key: textObj, defaultText: textObj };
+		}
+
+		if (!textObj || !textObj.key) {
 			return "";
 		}
-		const bundle = getI18nBundleData(this.packageName);
 
-		if (!bundle || !bundle[textObj.key]) {
-			return formatMessage(textObj.defaultText, params); // Fallback to "en"
+		const bundle = getI18nBundleData(this.packageName);
+		if (bundle && !bundle[textObj.key]) {
+			console.warn(`Key ${textObj.key} not found in the i18n bundle, the default text will be used`); // eslint-disable-line
 		}
+		const messageText = bundle && bundle[textObj.key] ? bundle[textObj.key] : (textObj.defaultText || textObj.key);
 
-		return formatMessage(bundle[textObj.key], params);
+		return formatMessage(messageText, params);
 	}
 }
 
-const getI18nBundle = packageName => {
+const getI18nBundleSync = packageName => {
 	if (I18nBundleInstances.has(packageName)) {
 		return I18nBundleInstances.get(packageName);
 	}
 
-	const i18nBunle = new I18nBundle(packageName);
-	I18nBundleInstances.set(packageName, i18nBunle);
-	return i18nBunle;
+	const i18nBundle = new I18nBundle(packageName);
+	I18nBundleInstances.set(packageName, i18nBundle);
+	return i18nBundle;
+};
+
+/**
+ * Allows developers to provide a custom getI18nBundle implementation
+ * If this function is called, the custom implementation will be used for all components and will completely
+ * replace the default implementation.
+ *
+ * @public
+ * @param customGet the function to use instead of the standard getI18nBundle implementation
+ */
+const registerCustomI18nBundleGetter = customGet => {
+	customGetI18nBundle = customGet;
+};
+
+/**
+ * Fetches and returns the I18nBundle instance for the given package
+ *
+ * @public
+ * @param packageName
+ * @returns {Promise<I18nBundle>}
+ */
+const getI18nBundle = async packageName => {
+	if (customGetI18nBundle) {
+		return customGetI18nBundle(packageName);
+	}
+
+	await fetchI18nBundle(packageName);
+	return getI18nBundleSync(packageName);
 };
 
-export { fetchI18nBundle, getI18nBundle };
+export {
+	registerI18nLoader,
+	getI18nBundle,
+	registerCustomI18nBundleGetter,
+};

package/src/isLegacyBrowser.js

@@ -0,0 +1,3 @@
+const isLegacyBrowser = () => !!window.ShadyDOM;
+
+export default isLegacyBrowser;

package/src/{Locale.js → locale/Locale.js}

@@ -1,5 +1,3 @@
-import getDesigntimePropertyAsArray from "./util/getDesigntimePropertyAsArray.js";
-
 const rLocale = /^((?:[A-Z]{2,3}(?:-[A-Z]{3}){0,3})|[A-Z]{4}|[A-Z]{5,8})(?:-([A-Z]{4}))?(?:-([A-Z]{2}|[0-9]{3}))?((?:-[0-9A-Z]{5,8}|-[0-9][0-9A-Z]{3})*)((?:-[0-9A-WYZ](?:-[0-9A-Z]{2,8})+)*)(?:-(X(?:-[0-9A-Z]{1,8})+))?$/i;
 
 class Locale {
@@ -88,14 +86,6 @@ class Locale {
 		}
 		return r.join("-");
 	}
-
-	static get _cldrLocales() {
-		return getDesigntimePropertyAsArray("$cldr-locales:ar,ar_EG,ar_SA,bg,br,ca,cs,da,de,de_AT,de_CH,el,el_CY,en,en_AU,en_GB,en_HK,en_IE,en_IN,en_NZ,en_PG,en_SG,en_ZA,es,es_AR,es_BO,es_CL,es_CO,es_MX,es_PE,es_UY,es_VE,et,fa,fi,fr,fr_BE,fr_CA,fr_CH,fr_LU,he,hi,hr,hu,id,it,it_CH,ja,kk,ko,lt,lv,ms,nb,nl,nl_BE,nn,pl,pt,pt_PT,ro,ru,ru_UA,sk,sl,sr,sv,th,tr,uk,vi,zh_CN,zh_HK,zh_SG,zh_TW$");
-	}
-
-	static get _coreI18nLocales() {
-		return getDesigntimePropertyAsArray("$core-i18n-locales:,ar,bg,ca,cs,da,de,el,en,es,et,fi,fr,hi,hr,hu,it,iw,ja,ko,lt,lv,nl,no,pl,pt,ro,ru,sh,sk,sl,sv,th,tr,uk,vi,zh_CN,zh_TW$");
-	}
 }
 
 export default Locale;

package/src/locale/RTLAwareRegistry.js

@@ -0,0 +1,14 @@
+const rtlAwareSet = new Set();
+
+const markAsRtlAware = klass => {
+	rtlAwareSet.add(klass);
+};
+
+const isRtlAware = klass => {
+	return rtlAwareSet.has(klass);
+};
+
+export {
+	markAsRtlAware,
+	isRtlAware,
+};

package/src/locale/applyDirection.js

@@ -0,0 +1,17 @@
+import { reRenderAllUI5Elements } from "../Render.js";
+import { fireDirectionChange } from "./directionChange.js";
+
+/**
+ * Re-renders all RTL-aware UI5 Elements.
+ * Call this method whenever you change the "dir" property anywhere in your HTML page
+ * Example: document.body.dir = "rtl"; applyDirection();
+ *
+ * @returns {Promise<void>}
+ */
+const applyDirection = async () => {
+	const listenersResults = fireDirectionChange();
+	await Promise.all(listenersResults);
+	await reRenderAllUI5Elements({ rtlAware: true });
+};
+
+export default applyDirection;

package/src/locale/directionChange.js

@@ -0,0 +1,32 @@
+import EventProvider from "../EventProvider.js";
+
+const eventProvider = new EventProvider();
+const DIR_CHANGE = "directionChange";
+
+/**
+ * Attach a callback that will be executed whenever the application calls the "applyDirection" function
+ * @public
+ * @param listener
+ */
+const attachDirectionChange = listener => {
+	eventProvider.attachEvent(DIR_CHANGE, listener);
+};
+
+/**
+ * Detach a callback that was passed with "attachDirectionChange"
+ * @public
+ * @param listener
+ */
+const detachDirectionChange = listener => {
+	eventProvider.detachEvent(DIR_CHANGE, listener);
+};
+
+const fireDirectionChange = () => {
+	return eventProvider.fireEvent(DIR_CHANGE);
+};
+
+export {
+	attachDirectionChange,
+	detachDirectionChange,
+	fireDirectionChange,
+};

package/src/locale/getEffectiveDir.js

@@ -0,0 +1,28 @@
+import { getRTL } from "../config/RTL.js";
+
+const GLOBAL_DIR_CSS_VAR = "--_ui5_dir";
+
+const getEffectiveDir = element => {
+	const doc = window.document;
+	const dirValues = ["ltr", "rtl"]; // exclude "auto" and "" from all calculations
+	const locallyAppliedDir = getComputedStyle(element).getPropertyValue(GLOBAL_DIR_CSS_VAR);
+
+	// In that order, inspect the CSS Var (for modern browsers), the element itself, html and body (for IE fallback)
+	if (dirValues.includes(locallyAppliedDir)) {
+		return locallyAppliedDir;
+	}
+	if (dirValues.includes(element.dir)) {
+		return element.dir;
+	}
+	if (dirValues.includes(doc.documentElement.dir)) {
+		return doc.documentElement.dir;
+	}
+	if (dirValues.includes(doc.body.dir)) {
+		return doc.body.dir;
+	}
+
+	// Finally, check the configuration for explicitly set RTL or language-implied RTL
+	return getRTL() ? "rtl" : undefined;
+};
+
+export default getEffectiveDir;