@ui5/webcomponents-base 0.0.0-389bdbabc → 0.0.0-453158269

package/dist/util/FocusableElements.js

@@ -1,48 +1,65 @@
-import UI5Element from "../UI5Element.js";
 import isNodeHidden from "./isNodeHidden.js";
 import isNodeClickable from "./isNodeClickable.js";
 
-const getFirstFocusableElement = container => {
+const isFocusTrap = el => {
+	return el.hasAttribute("data-ui5-focus-trap");
+};
+
+const getFirstFocusableElement = async (container, startFromContainer) => {
 	if (!container || isNodeHidden(container)) {
 		return null;
 	}
 
-	return findFocusableElement(container, true);
+	return findFocusableElement(container, true, startFromContainer);
 };
 
-const getLastFocusableElement = container => {
+const getLastFocusableElement = async (container, startFromContainer) => {
 	if (!container || isNodeHidden(container)) {
 		return null;
 	}
 
-	return findFocusableElement(container, false);
+	return findFocusableElement(container, false, startFromContainer);
 };
 
-const findFocusableElement = (container, forward) => {
+const isElemFocusable = el => {
+	return el.hasAttribute("data-ui5-focus-redirect") || !isNodeHidden(el);
+};
+
+const findFocusableElement = async (container, forward, startFromContainer) => {
 	let child;
-	if (container.assignedNodes && container.assignedNodes()) {
+
+	if (container.shadowRoot) {
+		child = forward ? container.shadowRoot.firstChild : container.shadowRoot.lastChild;
+	} else if (container.assignedNodes && container.assignedNodes()) {
 		const assignedElements = container.assignedNodes();
 		child = forward ? assignedElements[0] : assignedElements[assignedElements.length - 1];
+	} else if (startFromContainer) {
+		child = container;
 	} else {
-		child = forward ? container.firstChild : container.lastChild;
+		child = forward ? container.firstElementChild : container.lastElementChild;
 	}
 
 	let focusableDescendant;
 
+	/* eslint-disable no-await-in-loop */
+
 	while (child) {
 		const originalChild = child;
 
-		child = child instanceof UI5Element ? child.getFocusDomRef() : child;
+		if (child.isUI5Element) {
+			child = await child.getFocusDomRefAsync();
+		}
+
 		if (!child) {
 			return null;
 		}
 
-		if (child.nodeType === 1 && !isNodeHidden(child)) {
+		if (child.nodeType === 1 && isElemFocusable(child) && !isFocusTrap(child)) {
 			if (isNodeClickable(child)) {
 				return (child && typeof child.focus === "function") ? child : null;
 			}
 
-			focusableDescendant = findFocusableElement(child, forward);
+			focusableDescendant = await findFocusableElement(child, forward);
 			if (focusableDescendant) {
 				return (focusableDescendant && typeof focusableDescendant.focus === "function") ? focusableDescendant : null;
 			}
@@ -51,6 +68,8 @@ const findFocusableElement = (container, forward) => {
 		child = forward ? originalChild.nextSibling : originalChild.previousSibling;
 	}
 
+	/* eslint-enable no-await-in-loop */
+
 	return null;
 };
 

package/dist/util/HTMLSanitizer.js

@@ -0,0 +1,7 @@
+import sanitizeHTML from "../sap/base/security/sanitizeHTML.js";
+import URLListValidator from "../sap/base/security/URLListValidator.js";
+
+export {
+	URLListValidator,
+	sanitizeHTML,
+};

package/dist/util/InvisibleMessage.js

@@ -0,0 +1,60 @@
+import InvisibleMessageMode from "../types/InvisibleMessageMode.js";
+import getSingletonElementInstance from "./getSingletonElementInstance.js";
+import { attachBoot } from "../Boot.js";
+
+let politeSpan;
+let assertiveSpan;
+
+const setOutOfViewportStyles = el => {
+	el.style.position = "absolute";
+	el.style.clip = "rect(1px,1px,1px,1px)";
+	el.style.userSelect = "none";
+	el.style.left = "-1000px";
+	el.style.top = "-1000px";
+	el.style.pointerEvents = "none";
+};
+
+attachBoot(() => {
+	if (politeSpan && assertiveSpan) {
+		return;
+	}
+
+	politeSpan = document.createElement("span");
+	assertiveSpan = document.createElement("span");
+
+	politeSpan.classList.add("ui5-invisiblemessage-polite");
+	assertiveSpan.classList.add("ui5-invisiblemessage-assertive");
+
+	politeSpan.setAttribute("aria-live", "polite");
+	assertiveSpan.setAttribute("aria-live", "assertive");
+
+	politeSpan.setAttribute("role", "alert");
+	assertiveSpan.setAttribute("role", "alert");
+
+	setOutOfViewportStyles(politeSpan);
+	setOutOfViewportStyles(assertiveSpan);
+
+	getSingletonElementInstance("ui5-static-area").appendChild(politeSpan);
+	getSingletonElementInstance("ui5-static-area").appendChild(assertiveSpan);
+});
+
+/**
+ * Inserts the string into the respective span, depending on the mode provided.
+ *
+ * @param {string} message String to be announced by the screen reader.
+ * @param {sap.ui.core.InvisibleMessageMode} mode The mode to be inserted in the aria-live attribute.
+ */
+const announce = (message, mode) => {
+	// If no type is presented, fallback to polite announcement.
+	const span = mode === InvisibleMessageMode.Assertive ? assertiveSpan : politeSpan;
+
+	// Set textContent to empty string in order to trigger screen reader's announcement.
+	span.textContent = "";
+	span.textContent = message;
+
+	if (mode !== InvisibleMessageMode.Assertive && mode !== InvisibleMessageMode.Polite) {
+		console.warn(`You have entered an invalid mode. Valid values are: "Polite" and "Assertive". The framework will automatically set the mode to "Polite".`); // eslint-disable-line
+	}
+};
+
+export default announce;

package/dist/util/PopupUtils.js

@@ -0,0 +1,93 @@
+import getSharedResource from "../getSharedResource.js";
+import { getFeature } from "../FeaturesRegistry.js";
+import getActiveElement from "./getActiveElement.js";
+
+const PopupUtilsData = getSharedResource("PopupUtilsData", {});
+PopupUtilsData.currentZIndex = PopupUtilsData.currentZIndex || 100;
+
+const getFocusedElement = () => {
+	const element = getActiveElement();
+	return (element && typeof element.focus === "function") ? element : null;
+};
+
+const isFocusedElementWithinNode = node => {
+	const fe = getFocusedElement();
+
+	if (fe) {
+		return isNodeContainedWithin(node, fe);
+	}
+
+	return false;
+};
+
+const isNodeContainedWithin = (parent, child) => {
+	let currentNode = parent;
+
+	if (currentNode.shadowRoot) {
+		currentNode = Array.from(currentNode.shadowRoot.children).find(n => n.localName !== "style");
+	}
+
+	if (currentNode === child) {
+		return true;
+	}
+
+	const childNodes = currentNode.localName === "slot" ? currentNode.assignedNodes() : currentNode.children;
+
+	if (childNodes) {
+		return Array.from(childNodes).some(n => isNodeContainedWithin(n, child));
+	}
+};
+
+const isPointInRect = (x, y, rect) => {
+	return x >= rect.left && x <= rect.right
+		&& y >= rect.top && y <= rect.bottom;
+};
+
+const isClickInRect = (event, rect) => {
+	let x;
+	let y;
+
+	if (event.touches) {
+		const touch = event.touches[0];
+		x = touch.clientX;
+		y = touch.clientY;
+	} else {
+		x = event.clientX;
+		y = event.clientY;
+	}
+
+	return isPointInRect(x, y, rect);
+};
+
+const getClosedPopupParent = el => {
+	const parent = el.parentElement || (el.getRootNode && el.getRootNode().host);
+
+	if (parent && ((parent.showAt && parent.isUI5Element) || (parent.open && parent.isUI5Element) || parent === document.documentElement)) {
+		return parent;
+	}
+
+	return getClosedPopupParent(parent);
+};
+
+const getNextZIndex = () => {
+	const OpenUI5Support = getFeature("OpenUI5Support");
+	if (OpenUI5Support && OpenUI5Support.isLoaded()) { // use OpenUI5 for getting z-index values, if loaded
+		return OpenUI5Support.getNextZIndex();
+	}
+
+	PopupUtilsData.currentZIndex += 2;
+	return PopupUtilsData.currentZIndex;
+};
+
+const getCurrentZIndex = () => {
+	return PopupUtilsData.currentZIndex;
+};
+
+export {
+	getFocusedElement,
+	isClickInRect,
+	getClosedPopupParent,
+	getNextZIndex,
+	getCurrentZIndex,
+	isFocusedElementWithinNode,
+};

package/dist/util/SlotsHelper.js

@@ -0,0 +1,43 @@
+/**
+ * Determines the slot to which a node should be assigned
+ * @param node Text node or HTML element
+ * @returns {string}
+ */
+const getSlotName = node => {
+	// Text nodes can only go to the default slot
+	if (!(node instanceof HTMLElement)) {
+		return "default";
+	}
+
+	// Discover the slot based on the real slot name (f.e. footer => footer, or content-32 => content)
+	const slot = node.getAttribute("slot");
+	if (slot) {
+		const match = slot.match(/^(.+?)-\d+$/);
+		return match ? match[1] : slot;
+	}
+
+	// Use default slot as a fallback
+	return "default";
+};
+
+const isSlot = el => el && el instanceof HTMLElement && el.localName === "slot";
+
+const getSlottedElements = el => {
+	if (isSlot(el)) {
+		return el.assignedNodes({ flatten: true }).filter(item => item instanceof HTMLElement);
+	}
+
+	return [el];
+};
+
+const getSlottedElementsList = elList => {
+	const reducer = (acc, curr) => acc.concat(getSlottedElements(curr));
+	return elList.reduce(reducer, []);
+};
+
+export {
+	getSlotName,
+	isSlot,
+	getSlottedElements,
+	getSlottedElementsList,
+};

package/dist/util/StringHelper.js

@@ -1,6 +1,21 @@
-const kebabToCamelCase = string => toCamelCase(string.split("-"));
+const kebabToCamelMap = new Map();
+const camelToKebabMap = new Map();
 
-const camelToKebabCase = string => string.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+const kebabToCamelCase = string => {
+	if (!kebabToCamelMap.has(string)) {
+		const result = toCamelCase(string.split("-"));
+		kebabToCamelMap.set(string, result);
+	}
+	return kebabToCamelMap.get(string);
+};
+
+const camelToKebabCase = string => {
+	if (!camelToKebabMap.has(string)) {
+		const result = string.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+		camelToKebabMap.set(string, result);
+	}
+	return camelToKebabMap.get(string);
+};
 
 const toCamelCase = parts => {
 	return parts.map((string, index) => {

package/dist/util/TabbableElements.js

@@ -1,4 +1,3 @@
-
 import isNodeTabbable from "./isNodeTabbable.js";
 
 const getTabbableElements = node => {
@@ -13,8 +12,12 @@ const getLastTabbableElement = node => {
 const getTabbables = (nodes, tabbables) => {
 	const tabbablesNodes = tabbables || [];
 
+	if (!nodes) {
+		return tabbablesNodes;
+	}
+
 	Array.from(nodes).forEach(currentNode => {
-		if (currentNode.nodeType === Node.TEXT_NODE) {
+		if (currentNode.nodeType === Node.TEXT_NODE || currentNode.nodeType === Node.COMMENT_NODE || currentNode.hasAttribute("data-sap-no-tab-ref")) {
 			return;
 		}
 
@@ -24,6 +27,10 @@ const getTabbables = (nodes, tabbables) => {
 			currentNode = Array.from(children).find(node => node.tagName !== "STYLE");
 		}
 
+		if (!currentNode) {
+			return;
+		}
+
 		if (isNodeTabbable(currentNode)) {
 			tabbablesNodes.push(currentNode);
 		}

package/dist/util/arraysAreEqual.js

@@ -0,0 +1,15 @@
+const arraysAreEqual = (arr1, arr2) => {
+	if (arr1.length !== arr2.length) {
+		return false;
+	}
+
+	for (let i = 0; i < arr1.length; i++) {
+		if (arr1[i] !== arr2[i]) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+export default arraysAreEqual;

package/dist/util/clamp.js

@@ -0,0 +1,12 @@
+/**
+ * Returns a value clamped between an upper bound 'max' and lower bound 'min'.
+ * @param {number} val value
+ * @param {number} min lower bound
+ * @param {number} max upper bound
+ * @returns {number}
+ */
+const clamp = (val, min, max) => {
+	return Math.min(Math.max(val, min), max);
+};
+
+export default clamp;

package/dist/util/createLinkInHead.js

@@ -0,0 +1,19 @@
+/**
+ * Creates a <link> tag in the <head> tag
+ * @param href - the CSS
+ * @param attributes - optional attributes to add to the tag
+ * @returns {HTMLElement}
+ */
+const createLinkInHead = (href, attributes = {}) => {
+	const link = document.createElement("link");
+	link.type = "text/css";
+	link.rel = "stylesheet";
+
+	Object.entries(attributes).forEach(pair => link.setAttribute(...pair));
+
+	link.href = href;
+	document.head.appendChild(link);
+	return link;
+};
+
+export default createLinkInHead;

package/dist/util/debounce.js

@@ -0,0 +1,17 @@
+/**
+ * Delays function execution by given threshold.
+ * @param fn {Function}
+ * @param delay {Integer}
+ */
+
+let debounceInterval = null;
+
+const debounce = (fn, delay) => {
+	clearTimeout(debounceInterval);
+	debounceInterval = setTimeout(() => {
+		debounceInterval = null;
+		fn();
+	}, delay);
+};
+
+export default debounce;

package/dist/util/detectNavigatorLanguage.js

@@ -1,3 +1,5 @@
+import { DEFAULT_LANGUAGE } from "../generated/AssetParameters.js";
+
 export default () => {
 	const browserLanguages = navigator.languages;
 
@@ -7,5 +9,5 @@ export default () => {
 
 	const rawLocale = (browserLanguages && browserLanguages[0]) || navigatorLanguage() || navigator.userLanguage || navigator.browserLanguage;
 
-	return rawLocale || "en";
+	return rawLocale || DEFAULT_LANGUAGE;
 };

package/dist/util/escapeRegex.js

@@ -0,0 +1,10 @@
+/**
+ * Escape a regular expression text so that it can be used in a regular expression.
+ * @param {string} text The string to be interpreted literally
+ * @returns Regular expression string to pass to regex
+ */
+function escapeRegex(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export default escapeRegex;

package/dist/util/findNodeOwner.js

@@ -0,0 +1,35 @@
+const findNodeOwner = node => {
+	if (!(node instanceof HTMLElement)) {
+		throw new Error("Argument node should be of type HTMLElement");
+	}
+
+	const ownerTypes = [HTMLHtmlElement, HTMLIFrameElement];
+	let currentShadowRootFlag = true;
+	let currentCustomElementFlag = true;
+
+	while (node) {
+		if (node.toString() === "[object ShadowRoot]") {
+			// Web Component
+			// or the shadow root of web component with attached shadow root
+			if (currentShadowRootFlag) {
+				currentShadowRootFlag = false;
+			}
+			if (!currentCustomElementFlag && !currentShadowRootFlag) {
+				return node;
+			}
+		} else if (node.tagName && node.tagName.indexOf("-") > -1) {
+			if (currentCustomElementFlag) {
+				currentCustomElementFlag = false;
+			} else {
+				return node;
+			}
+		} else if (ownerTypes.indexOf(node.constructor) > -1) {
+			// Document or Iframe reached
+			return node;
+		}
+
+		node = node.parentNode || node.host;
+	}
+};
+
+export default findNodeOwner;

package/dist/util/generateHighlightedMarkup.js

@@ -0,0 +1,42 @@
+import escapeRegex from "./escapeRegex.js";
+import encodeXML from "../sap/base/security/encodeXML.js";
+
+// utility to replace all occurances of a string
+function replaceAll(text, find, replace, caseInsensitive) {
+	return text.replace(new RegExp(escapeRegex(find), `${caseInsensitive ? "i" : ""}g`), replace);
+}
+
+/**
+ * Generate markup for a raw string where a particular text is wrapped with some tag, by default `<b>` (bold) tag.
+ * All inputs to this function are considered literal text, and special characters will always be escaped.
+ * @param {string} text The text to add highlighting to
+ * @param {string} textToHighlight The text which should be highlighted
+ * @return {string} the markup HTML which contains all occurrances of the input text surrounded with a `<b>` tag.
+ */
+function generateHighlightedMarkup(text, textToHighlight) {
+	if (!text || !textToHighlight) {
+		return text;
+	}
+	// a token is some string that does not appear in either of the input strings
+	// repeat the token until it does not appear in the string
+	const makeToken = t => {
+		const [s, e] = t.split("");
+		while (text.indexOf(t) >= 0 || textToHighlight.indexOf(t) >= 0) {
+			t = `${s}${t}${e}`;
+		}
+		return t;
+	};
+	// It doesn't matter what characters are used as long as all 4 of them are unique
+	// And also that encodeXML will not change these characters
+	const openToken = makeToken("12");
+	const closeToken = makeToken("34");
+	// wrap every occurance of the textToHighlight using the open/close tokens (instead of markup at this point)
+	let result = encodeXML(replaceAll(text, textToHighlight, match => `${openToken}${match}${closeToken}`, true));
+	// now replace the open and close tokens with the markup that we expect
+	[[openToken, "<b>"], [closeToken, "</b>"]].forEach(([find, replace]) => {
+		result = replaceAll(result, find, replace);
+	});
+	return result;
+}
+
+export default generateHighlightedMarkup;

package/dist/util/getActiveElement.js

@@ -0,0 +1,11 @@
+const getActiveElement = () => {
+	let element = document.activeElement;
+
+	while (element && element.shadowRoot && element.shadowRoot.activeElement) {
+		element = element.shadowRoot.activeElement;
+	}
+
+	return element;
+};
+
+export default getActiveElement;

package/dist/util/getClassCopy.js

@@ -0,0 +1,10 @@
+const getClassCopy = (klass, constructorCallback) => {
+	return class classCopy extends klass {
+		constructor() {
+			super();
+			constructorCallback && constructorCallback();
+		}
+	};
+};
+
+export default getClassCopy;

package/dist/util/getEffectiveContentDensity.js

@@ -0,0 +1,5 @@
+const GLOBAL_CONTENT_DENSITY_CSS_VAR = "--_ui5_content_density";
+
+const getEffectiveContentDensity = el => getComputedStyle(el).getPropertyValue(GLOBAL_CONTENT_DENSITY_CSS_VAR);
+
+export default getEffectiveContentDensity;

package/dist/util/getFileExtension.js

@@ -0,0 +1,21 @@
+/**
+ * ""                        -> ""
+ * "noExtension"             -> ""
+ * "file.txt"                -> ".txt"
+ * "file.with.many.dots.doc" -> ".doc"
+ * ".gitignore"              -> ""
+ *
+ * @param fileName - the file name
+ * @returns {string}
+ */
+const getFileExtension = fileName => {
+	const dotPos = fileName.lastIndexOf(".");
+
+	if (dotPos < 1) {
+		return "";
+	}
+
+	return fileName.slice(dotPos);
+};
+
+export default getFileExtension;

package/dist/util/getNormalizedTarget.js

@@ -0,0 +1,16 @@
+/**
+ * Returns the normalized event target in cases when it has shadow root.
+ * @param {Object} target The original event target
+ * @returns {Object} The normalized target
+ */
+const getNormalizedTarget = target => {
+	let element = target;
+
+	if (target.shadowRoot && target.shadowRoot.activeElement) {
+		element = target.shadowRoot.activeElement;
+	}
+
+	return element;
+};
+
+export default getNormalizedTarget;

package/dist/util/getSingletonElementInstance.js

@@ -0,0 +1,13 @@
+const getSingletonElementInstance = (tag, parentElement = document.body) => {
+	let el = document.querySelector(tag);
+
+	if (el) {
+		return el;
+	}
+
+	el = document.createElement(tag);
+
+	return parentElement.insertBefore(el, parentElement.firstChild);
+};
+
+export default getSingletonElementInstance;

package/dist/util/isElementInView.js

@@ -0,0 +1,15 @@
+/**
+ * Determines if the element is within the viewport.
+ * @param el {HTMLElement}
+ */
+const isElementInView = el => {
+	const rect = el.getBoundingClientRect();
+
+	return (
+		rect.top >= 0 && rect.left >= 0
+			&& rect.bottom <= (window.innerHeight || document.documentElement.clientHeight)
+			&& rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+	);
+};
+
+export default isElementInView;

package/dist/util/isNodeHidden.js

@@ -3,11 +3,7 @@ const isNodeHidden = node => {
 		return false;
 	}
 
-	const rect = node.getBoundingClientRect();
-
-	return (node.offsetWidth <= 0 && node.offsetHeight <= 0)
-		|| node.style.visibility === "hidden"
-		|| (rect.width === 0 && 0 && rect.height === 0);
+	return (node.offsetWidth <= 0 && node.offsetHeight <= 0) || (node.style && node.style.visibility === "hidden");
 };
 
 export default isNodeHidden;

package/dist/util/isNodeTabbable.js

@@ -15,14 +15,14 @@ const isNodeTabbable = node => {
 		return false;
 	}
 
-	if (nodeName === "a" || /input|select|textarea|button|object/.test(nodeName)) {
-		return !node.disabled;
-	}
-
 	const tabIndex = node.getAttribute("tabindex");
 	if (tabIndex !== null && tabIndex !== undefined) {
 		return parseInt(tabIndex) >= 0;
 	}
+
+	if (nodeName === "a" || /input|select|textarea|button|object/.test(nodeName)) {
+		return !node.disabled;
+	}
 };
 
 export default isNodeTabbable;

package/dist/util/isValidPropertyName.js

@@ -1,12 +1,21 @@
+// Note: disabled is present in IE so we explicitly allow it here.
+// Others, such as title/hidden, we explicitly override, so valid too
+const allowList = [
+	"disabled",
+	"title",
+	"hidden",
+	"role",
+	"draggable",
+];
+
 /**
  * Checks whether a property name is valid (does not collide with existing DOM API properties)
- * Note: disabled is present in IE so we explicitly allow it here.
  *
  * @param name
  * @returns {boolean}
  */
 const isValidPropertyName = name => {
-	if (name === "disabled") {
+	if (allowList.includes(name) || name.startsWith("aria")) {
 		return true;
 	}
 	const classes = [