@ui5/webcomponents-base 0.0.0-5f8ce9393 → 0.0.0-6cb3eb0db

package/src/delegate/ScrollEnablement.js

@@ -1,15 +1,37 @@
+import { supportsTouch } from "../Device.js";
 import EventProvider from "../EventProvider.js";
 import scroll from "../animations/scroll.js";
 
 const scrollEventName = "scroll";
-const touchEndEventName = "touchend";
+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 });
-		containerComponent.addEventListener("touchend", this.ontouchend.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) {
@@ -20,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,
@@ -43,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._canScroll = this._isTouchInside(touch);
+		this._prevDragX = this.supportsTouch ? touch.pageX : event.x;
+		this._prevDragY = this.supportsTouch ? touch.pageY : event.y;
+
+		this._canScroll = this._isTouchInside(this.supportsTouch ? touch : event);
 	}
 
 	ontouchmove(event) {
@@ -64,10 +125,10 @@ 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;
@@ -77,29 +138,50 @@ class ScrollEnablement extends EventProvider {
 			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 = event.pageX;
-		const dragY = event.pageY;
+		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,
+			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);
+		}
 	}
 }
 

package/src/features/OpenUI5Support.js

@@ -1,32 +1,41 @@
 import { registerFeature } from "../FeaturesRegistry.js";
 import { setTheme } from "../config/Theme.js";
+import { getCurrentZIndex } from "../util/PopupUtils.js";
 
-const sap = window.sap;
-const core = sap && sap.ui && typeof sap.ui.getCore === "function" && sap.ui.getCore();
+const getCore = () => {
+	const sap = window.sap;
+	const core = sap && sap.ui && typeof sap.ui.getCore === "function" && sap.ui.getCore();
+	return core;
+};
 
 const isLoaded = () => {
-	return !!core;
+	return !!getCore();
 };
 
 const init = () => {
+	const core = getCore();
 	if (!core) {
 		return Promise.resolve();
 	}
 
 	return new Promise(resolve => {
 		core.attachInit(() => {
-			sap.ui.require(["sap/ui/core/LocaleData"], resolve);
+			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 = sap.ui.require("sap/ui/core/LocaleData");
+	const LocaleData = window.sap.ui.require("sap/ui/core/LocaleData");
 
 	return {
 		animationMode: config.getAnimationMode(),
@@ -35,22 +44,24 @@ const getConfigurationSettingsObject = () => {
 		rtl: config.getRTL(),
 		calendarType: config.getCalendarType(),
 		formatSettings: {
-			firstDayOfWeek: LocaleData.getInstance(config.getLocale()).getFirstDayOfWeek(),
+			firstDayOfWeek: LocaleData ? LocaleData.getInstance(config.getLocale()).getFirstDayOfWeek() : undefined,
 		},
 	};
 };
 
 const getLocaleDataObject = () => {
+	const core = getCore();
 	if (!core) {
 		return;
 	}
 
 	const config = core.getConfiguration();
-	const LocaleData = sap.ui.require("sap/ui/core/LocaleData");
-	return LocaleData.getInstance(config.getLocale()).mData;
+	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());
@@ -58,6 +69,7 @@ const listenForThemeChange = () => {
 };
 
 const attachListeners = () => {
+	const core = getCore();
 	if (!core) {
 		return;
 	}
@@ -65,12 +77,49 @@ const attachListeners = () => {
 	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,24 +1,41 @@
-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();
 
+/**
+ * @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);
 	}
 }
 
@@ -27,9 +44,13 @@ const getI18nBundle = 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;
 };
 
-export { fetchI18nBundle, getI18nBundle };
+export {
+	registerI18nLoader,
+	fetchI18nBundle,
+	getI18nBundle,
+};

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;

package/src/locale/getLocale.js

@@ -0,0 +1,41 @@
+import detectNavigatorLanguage from "../util/detectNavigatorLanguage.js";
+import { getLanguage as getConfigLanguage } from "../config/Language.js";
+import Locale from "./Locale.js";
+
+const cache = new Map();
+
+const getLocaleInstance = lang => {
+	if (!cache.has(lang)) {
+		cache.set(lang, new Locale(lang));
+	}
+
+	return cache.get(lang);
+};
+
+const convertToLocaleOrNull = lang => {
+	try {
+		if (lang && typeof lang === "string") {
+			return getLocaleInstance(lang);
+		}
+	} catch (e) {
+		// ignore
+	}
+};
+
+/**
+ * Returns the locale based on the parameter or configured language Configuration#getLanguage
+ * If no language has been configured - a new locale based on browser language is returned
+ */
+const getLocale = lang => {
+	if (lang) {
+		return convertToLocaleOrNull(lang);
+	}
+
+	if (getConfigLanguage()) {
+		return getLocaleInstance(getConfigLanguage());
+	}
+
+	return convertToLocaleOrNull(detectNavigatorLanguage());
+};
+
+export default getLocale;

package/src/locale/languageChange.js

@@ -0,0 +1,22 @@
+import EventProvider from "../EventProvider.js";
+
+const eventProvider = new EventProvider();
+const LANG_CHANGE = "languageChange";
+
+const attachLanguageChange = listener => {
+	eventProvider.attachEvent(LANG_CHANGE, listener);
+};
+
+const detachLanguageChange = listener => {
+	eventProvider.detachEvent(LANG_CHANGE, listener);
+};
+
+const fireLanguageChange = lang => {
+	return eventProvider.fireEventAsync(LANG_CHANGE, lang);
+};
+
+export {
+	attachLanguageChange,
+	detachLanguageChange,
+	fireLanguageChange,
+};

package/src/locale/nextFallbackLocale.js

@@ -0,0 +1,28 @@
+import { DEFAULT_LOCALE } from "../generated/AssetParameters.js";
+
+/**
+ * Calculates the next fallback locale for the given locale.
+ *
+ * @param {string} locale Locale string in Java format (underscores) or null
+ * @returns {string} Next fallback Locale or "en" if no fallbacks found.
+ */
+const nextFallbackLocale = locale => {
+	if (!locale) {
+		return DEFAULT_LOCALE;
+	}
+
+	if (locale === "zh_HK") {
+		return "zh_TW";
+	}
+
+	// if there are multiple segments (separated by underscores), remove the last one
+	const p = locale.lastIndexOf("_");
+	if (p >= 0) {
+		return locale.slice(0, p);
+	}
+
+	// for any language but the default, fallback to the default first before falling back to the 'raw' language (empty string)
+	return locale !== DEFAULT_LOCALE ? DEFAULT_LOCALE : "";
+};
+
+export default nextFallbackLocale;