@ui5/webcomponents-base 0.0.0-e7dd012d7 → 0.0.0-e818f286e

package/src/delegate/ResizeHandler.js

@@ -1,65 +1,106 @@
-import NativeResize from "./NativeResize.js";
-import CustomResize from "./CustomResize.js";
+let resizeObserver;
+const observedElements = new Map();
 
-class ResizeHandler {
-	static initialize() {
-		ResizeHandler.Implementation = window.ResizeObserver ? NativeResize : CustomResize;
-		ResizeHandler.Implementation.initialize();
+const getResizeObserver = () => {
+	if (!resizeObserver) {
+		resizeObserver = new window.ResizeObserver(entries => {
+			entries.forEach(entry => {
+				const callbacks = observedElements.get(entry.target);
+				callbacks.forEach(callback => callback());
+			});
+		});
 	}
+	return resizeObserver;
+};
 
-	/**
-	 * @static
-	 * @private
-	 * @param {*} ref Reference to be observed
-	 * @param {*} callback Callback to be executed
-	 * @memberof ResizeHandler
-	 */
-	static attachListener(ref, callback) {
-		ResizeHandler.Implementation.attachListener.call(ResizeHandler.Implementation, ref, callback);
+let observe = (element, callback) => {
+	const callbacks = observedElements.get(element) || [];
+
+	// if no callbacks have been added for this element - start observing it
+	if (!callbacks.length) {
+		getResizeObserver().observe(element);
 	}
 
-	/**
-	 * @static
-	 * @private
-	 * @param {*} ref Reference to be unobserved
-	 * @memberof ResizeHandler
-	 */
-	static detachListener(ref, callback) {
-		ResizeHandler.Implementation.detachListener.call(ResizeHandler.Implementation, ref, callback);
+	// save the callbacks in an array
+	observedElements.set(element, [...callbacks, callback]);
+};
+
+let unobserve = (element, callback) => {
+	const callbacks = observedElements.get(element) || [];
+	if (callbacks.length === 0) {
+		return;
 	}
 
+	const filteredCallbacks = callbacks.filter(fn => fn !== callback);
+	if (filteredCallbacks.length === 0) {
+		getResizeObserver().unobserve(element);
+		observedElements.delete(element);
+	} else {
+		observedElements.set(element, filteredCallbacks);
+	}
+};
 
+/**
+ * Allows to register/deregister resize observers for a DOM element
+ *
+ * @public
+ * @class
+  */
+class ResizeHandler {
 	/**
 	 * @static
 	 * @public
-	 * @param {*} ref Reference to a UI5 Web Component or DOM Element to be observed
+	 * @param {*} element UI5 Web Component or DOM Element to be observed
 	 * @param {*} callback Callback to be executed
-	 * @memberof ResizeHandler
 	 */
-	static register(ref, callback) {
-		if (ref.isUI5Element) {
-			ref = ref.getDomRef();
+	static register(element, callback) {
+		if (element.isUI5Element) {
+			element = element.getDomRef();
 		}
 
-		ResizeHandler.attachListener(ref, callback);
+		if (element instanceof HTMLElement) {
+			observe(element, callback);
+		} else {
+			console.warn("Cannot register ResizeHandler for element", element); // eslint-disable-line
+		}
 	}
 
-
 	/**
 	 * @static
 	 * @public
-	 * @param {*} ref Reference to UI5 Web Component or DOM Element to be unobserved
-	 * @memberof ResizeHandler
+	 * @param {*} element UI5 Web Component or DOM Element to be unobserved
+	 * @param {*} callback Callback to be removed
 	 */
-	static deregister(ref, callback) {
-		if (ref.isUI5Element) {
-			ref = ref.getDomRef();
+	static deregister(element, callback) {
+		if (element.isUI5Element) {
+			element = element.getDomRef();
 		}
 
-		ResizeHandler.detachListener(ref, callback);
+		if (element instanceof HTMLElement) {
+			unobserve(element, callback);
+		} else {
+			console.warn("Cannot deregister ResizeHandler for element", element); // eslint-disable-line
+		}
 	}
 }
 
-ResizeHandler.initialize();
+/**
+ * Set a function to be executed whenever a DOM node needs to be observed for size change.
+ * @public
+ * @param fn
+ */
+const setResizeHandlerObserveFn = fn => {
+	observe = fn;
+};
+
+/**
+ * Set a function to be executed whenever a DOM node needs to no longer be observed for size changes
+ * @public
+ * @param fn
+ */
+const setResizeHandlerUnobserveFn = fn => {
+	unobserve = fn;
+};
 
 export default ResizeHandler;
+export { setResizeHandlerObserveFn, setResizeHandlerUnobserveFn };

package/src/delegate/ScrollEnablement.js

@@ -1,9 +1,9 @@
-import { isPhone } from "../Device.js";
+import { supportsTouch } from "../Device.js";
 import EventProvider from "../EventProvider.js";
 import scroll from "../animations/scroll.js";
 
 const scrollEventName = "scroll";
-const touchEndEventName = isPhone() ? "touchend" : "mouseup";
+const touchEndEventName = supportsTouch() ? "touchend" : "mouseup";
 
 class ScrollEnablement extends EventProvider {
 	constructor(containerComponent) {
@@ -13,7 +13,7 @@ class ScrollEnablement extends EventProvider {
 		this.mouseUp = this.ontouchend.bind(this);
 		this.touchStart = this.ontouchstart.bind(this);
 
-		this.isPhone = isPhone();
+		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
@@ -25,7 +25,7 @@ class ScrollEnablement extends EventProvider {
 		this.startX = 0;
 		this.startY = 0;
 
-		if (this.isPhone) {
+		if (this.supportsTouch) {
 			containerComponent.addEventListener("touchstart", this.touchStart, { passive: true });
 			containerComponent.addEventListener("touchmove", this.mouseMove, { passive: true });
 			containerComponent.addEventListener("touchend", this.mouseUp, { passive: true });
@@ -42,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,
@@ -65,17 +94,17 @@ class ScrollEnablement extends EventProvider {
 
 	_isTouchInside(touch) {
 		const rect = this._container.getBoundingClientRect();
-		const x = this.isPhone ? touch.clientX : touch.x;
-		const y = this.isPhone ? touch.clientY : touch.y;
+		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 = this.isPhone ? event.touches[0] : null;
+		const touch = this.supportsTouch ? event.touches[0] : null;
 
-		if (!this.isPhone) {
+		if (!this.supportsTouch) {
 			document.addEventListener("mouseup", this.mouseUp, { passive: true });
 			document.addEventListener("mousemove", this.mouseMove, { passive: true });
 		} else {
@@ -84,10 +113,10 @@ class ScrollEnablement extends EventProvider {
 			this.startY = touch.pageY;
 		}
 
-		this._prevDragX = this.isPhone ? touch.pageX : event.x;
-		this._prevDragY = this.isPhone ? touch.pageY : event.y;
+		this._prevDragX = this.supportsTouch ? touch.pageX : event.x;
+		this._prevDragY = this.supportsTouch ? touch.pageY : event.y;
 
-		this._canScroll = this._isTouchInside(this.isPhone ? touch : event);
+		this._canScroll = this._isTouchInside(this.supportsTouch ? touch : event);
 	}
 
 	ontouchmove(event) {
@@ -96,10 +125,10 @@ class ScrollEnablement extends EventProvider {
 		}
 
 		const container = this._container;
-		const touch = this.isPhone ? event.touches[0] : null;
+		const touch = this.supportsTouch ? event.touches[0] : null;
 
-		const dragX = this.isPhone ? touch.pageX : event.x;
-		const dragY = this.isPhone ? touch.pageY : event.y;
+		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;
@@ -117,7 +146,7 @@ class ScrollEnablement extends EventProvider {
 	}
 
 	ontouchend(event) {
-		if (this.isPhone) {
+		if (this.supportsTouch) {
 			const deltaX = Math.abs(event.changedTouches[0].pageX - this.startX);
 			const deltaY = Math.abs(event.changedTouches[0].pageY - this.startY);
 
@@ -131,8 +160,8 @@ class ScrollEnablement extends EventProvider {
 		}
 
 		const container = this._container;
-		const dragX = this.isPhone ? event.changedTouches[0].pageX : event.x;
-		const dragY = this.isPhone ? event.changedTouches[0].pageY : event.y;
+		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;
@@ -149,7 +178,7 @@ class ScrollEnablement extends EventProvider {
 		this._prevDragX = dragX;
 		this._prevDragY = dragY;
 
-		if (!this.isPhone) {
+		if (!this.supportsTouch) {
 			document.removeEventListener("mousemove", this.mouseMove, { passive: true });
 			document.removeEventListener("mouseup", this.mouseUp);
 		}

package/src/features/F6Navigation.js

@@ -0,0 +1,110 @@
+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;
+			}
+
+			event.preventDefault();
+
+			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;
+			}
+
+			event.preventDefault();
+
+			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/OpenUI5Enablement.js

@@ -0,0 +1,119 @@
+import { registerFeature } from "../FeaturesRegistry.js";
+import BusyIndicatorStyles from "../generated/css/BusyIndicator.css.js";
+import merge from "../thirdparty/merge.js";
+import {
+	isTabPrevious,
+} from "../Keys.js";
+
+const busyIndicatorMetadata = {
+	properties: {
+		__isBusy: {
+			type: Boolean,
+		},
+	},
+};
+
+const getBusyIndicatorStyles = () => {
+	return BusyIndicatorStyles;
+};
+
+const wrapTemplateResultInBusyMarkup = (html, host, templateResult) => {
+	if (host.isOpenUI5Component && host.__isBusy) {
+		templateResult = html`
+		<div class="busy-indicator-wrapper">
+			<span tabindex="0" busy-indicator-before-span @focusin=${host.__suppressFocusIn}></span>
+			${templateResult}
+			<div class="busy-indicator-overlay"></div>
+			<div busy-indicator
+				class="busy-indicator-busy-area"
+				tabindex="0"
+				role="progressbar"
+				@keydown=${host.__suppressFocusBack}
+				aria-valuemin="0"
+				aria-valuemax="100"
+				aria-valuetext="Busy">
+				<div>
+					<div class="busy-indicator-circle circle-animation-0"></div>
+					<div class="busy-indicator-circle circle-animation-1"></div>
+					<div class="busy-indicator-circle circle-animation-2"></div>
+				</div>
+			</div>
+		</div>`;
+	}
+
+	return templateResult;
+};
+
+const enrichBusyIndicatorMetadata = UI5Element => {
+	UI5Element.metadata = merge(UI5Element.metadata, busyIndicatorMetadata);
+};
+
+const enrichBusyIndicatorMethods = UI5ElementPrototype => {
+	Object.defineProperties(UI5ElementPrototype, {
+		"__redirectFocus": { value: true, writable: true },
+		"__suppressFocusBack": {
+			get() {
+				const that = this;
+
+				return {
+					handleEvent: e => {
+						if (isTabPrevious(e)) {
+							const beforeElem = that.shadowRoot.querySelector("[busy-indicator-before-span]");
+							that.__redirectFocus = false;
+							beforeElem.focus();
+							that.__redirectFocus = true;
+						}
+					},
+					capture: true,
+					passive: false,
+				};
+			},
+		},
+		"isOpenUI5Component": { get: () => { return true; } },
+	});
+
+	UI5ElementPrototype.__suppressFocusIn = function handleFocusIn() {
+		const busyIndicator = this.shadowRoot.querySelector("[busy-indicator]");
+		if (busyIndicator && this.__redirectFocus) {
+			busyIndicator.focus();
+		}
+	};
+
+	UI5ElementPrototype.getDomRef = function getDomRef() {
+		// If a component set _getRealDomRef to its children, use the return value of this function
+		if (typeof this._getRealDomRef === "function") {
+			return this._getRealDomRef();
+		}
+
+		if (!this.shadowRoot || this.shadowRoot.children.length === 0) {
+			return;
+		}
+
+		const children = [...this.shadowRoot.children].filter(child => !["link", "style"].includes(child.localName));
+
+		if (children.length !== 1) {
+			console.warn(`The shadow DOM for ${this.constructor.getMetadata().getTag()} does not have a top level element, the getDomRef() method might not work as expected`); // eslint-disable-line
+		}
+
+		if (this.__isBusy) {
+			return children[0].querySelector(".busy-indicator-wrapper > :not([busy-indicator-before-span]):not(.busy-indicator-overlay):not(.busy-indicator-busy-area)");
+		}
+
+		return children[0];
+	};
+};
+
+const enrichBusyIndicatorSettings = UI5Element => {
+	enrichBusyIndicatorMetadata(UI5Element);
+	enrichBusyIndicatorMethods(UI5Element.prototype);
+};
+
+const OpenUI5Enablement = {
+	enrichBusyIndicatorSettings,
+	wrapTemplateResultInBusyMarkup,
+	getBusyIndicatorStyles,
+};
+
+export default OpenUI5Enablement;
+
+registerFeature("OpenUI5Enablement", OpenUI5Enablement);

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(),
@@ -41,16 +50,18 @@ const getConfigurationSettingsObject = () => {
 };
 
 const getLocaleDataObject = () => {
+	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 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;
 	}
@@ -66,6 +78,7 @@ const attachListeners = () => {
 };
 
 const cssVariablesLoaded = () => {
+	const core = getCore();
 	if (!core) {
 		return;
 	}
@@ -78,6 +91,26 @@ const cssVariablesLoaded = () => {
 	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,
@@ -85,6 +118,8 @@ const OpenUI5Support = {
 	getLocaleDataObject,
 	attachListeners,
 	cssVariablesLoaded,
+	getNextZIndex,
+	setInitialZIndex,
 };
 
 registerFeature("OpenUI5Support", OpenUI5Support);