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

package/dist/EventProvider.js

@@ -1,72 +1,84 @@
 class EventProvider {
 	constructor() {
-		this._eventRegistry = {};
+		this._eventRegistry = new Map();
 	}
 
 	attachEvent(eventName, fnFunction) {
 		const eventRegistry = this._eventRegistry;
-		let eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!Array.isArray(eventListeners)) {
-			eventRegistry[eventName] = [];
-			eventListeners = eventRegistry[eventName];
+			eventRegistry.set(eventName, [fnFunction]);
+			return;
 		}
 
-		eventListeners.push({
-			"function": fnFunction,
-		});
+		if (!eventListeners.includes(fnFunction)) {
+			eventListeners.push(fnFunction);
+		}
 	}
 
 	detachEvent(eventName, fnFunction) {
 		const eventRegistry = this._eventRegistry;
-		let eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!eventListeners) {
 			return;
 		}
+		const indexOfFnToDetach = eventListeners.indexOf(fnFunction);
 
-		eventListeners = eventListeners.filter(event => {
-			return event["function"] !== fnFunction; // eslint-disable-line
-		});
+		if (indexOfFnToDetach !== -1) {
+			eventListeners.splice(indexOfFnToDetach, 1);
+		}
 
 		if (eventListeners.length === 0) {
-			delete eventRegistry[eventName];
+			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, data) {
 		const eventRegistry = this._eventRegistry;
-		const eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!eventListeners) {
-			return;
+			return [];
 		}
 
-		eventListeners.forEach(event => {
-			event["function"].call(this, data); // eslint-disable-line
+		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, data) {
+		return Promise.all(this.fireEvent(eventName, data));
+	}
+
 	isHandlerAttached(eventName, fnFunction) {
 		const eventRegistry = this._eventRegistry;
-		const eventListeners = eventRegistry[eventName];
+		const eventListeners = eventRegistry.get(eventName);
 
 		if (!eventListeners) {
 			return false;
 		}
 
-		for (let i = 0; i < eventListeners.length; i++) {
-			const event = eventListeners[i];
-			if (event["function"] === fnFunction) { // eslint-disable-line
-				return true;
-			}
-		}
-
-		return false;
+		return eventListeners.includes(fnFunction);
 	}
 
 	hasListeners(eventName) {
-		return !!this._eventRegistry[eventName];
+		return !!this._eventRegistry.get(eventName);
 	}
 }
 

package/dist/FontFace.js

@@ -56,18 +56,63 @@ const fontFaceCSS = `
 	}
 `;
 
-const insertFontFace = () => {
-	if (document.querySelector(`head>style[data-ui5-font-face]`)) {
-		return;
+/**
+ * Some diacritics are supported by the 72 font:
+ *  * Grave
+ *  * Acute
+ *  * Circumflex
+ *  * Tilde
+ *
+ * However, the following diacritics and the combination of multiple diacritics (including the supported ones) are not supported:
+ *  * Breve
+ *  * Horn
+ *  * Dot below
+ *  * Hook above
+ *
+ *
+ * Override for the characters that aren't covered by the '72' font to other system fonts
+ *
+ * U+0102-0103: A and a with Breve
+ * U+01A0-01A1: O and o with Horn
+ * U+01AF-01B0: U and u with Horn
+ * U+1EA0-1EB7: A and a with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EB8-1EC7: E and e with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EC8-1ECB: I and i with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1ECC-1EE3: O and o with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EE4-1EF1: U and u with diacritics that are not supported by the font and combination of multiple diacritics
+ * U+1EF4-1EF7: Y and y with diacritics that are not supported by the font and combination of multiple diacritics
+ *
+ */
+const overrideFontFaceCSS = `
+	@font-face {
+		font-family: '72override';
+		unicode-range: U+0102-0103, U+01A0-01A1, U+01AF-01B0, U+1EA0-1EB7, U+1EB8-1EC7, U+1EC8-1ECB, U+1ECC-1EE3, U+1EE4-1EF1, U+1EF4-1EF7;
+		src: local('Arial'), local('Helvetica'), local('sans-serif');
 	}
+`;
 
-	// If OpenUI5 is found, let it set the font
+const insertFontFace = () => {
 	const OpenUI5Support = getFeature("OpenUI5Support");
-	if (OpenUI5Support && OpenUI5Support.isLoaded()) {
-		return;
+
+	// Only set the main font if there is no OpenUI5 support, or there is, but OpenUI5 is not loaded
+	if (!OpenUI5Support || !OpenUI5Support.isLoaded()) {
+		insertMainFontFace();
 	}
 
-	createStyleInHead(fontFaceCSS, { "data-ui5-font-face": "" });
+	// Always set the override font - OpenUI5 in CSS Vars mode does not set it, unlike the main font
+	insertOverrideFontFace();
+};
+
+const insertMainFontFace = () => {
+	if (!document.querySelector(`head>style[data-ui5-font-face]`)) {
+		createStyleInHead(fontFaceCSS, { "data-ui5-font-face": "" });
+	}
+};
+
+const insertOverrideFontFace = () => {
+	if (!document.querySelector(`head>style[data-ui5-font-face-override]`)) {
+		createStyleInHead(overrideFontFaceCSS, { "data-ui5-font-face-override": "" });
+	}
 };
 
 export default insertFontFace;

package/dist/InitialConfiguration.js

@@ -1,16 +1,18 @@
-import merge from "@ui5/webcomponents-utils/dist/sap/base/util/merge.js";
+import merge from "./thirdparty/merge.js";
 import { getFeature } from "./FeaturesRegistry.js";
+import { DEFAULT_THEME } from "./generated/AssetParameters.js";
 
 let initialized = false;
 
 let initialConfig = {
 	animationMode: "full",
-	theme: "sap_fiori_3",
+	theme: DEFAULT_THEME,
 	rtl: null,
 	language: null,
 	calendarType: null,
 	noConflict: false, // no URL
 	formatSettings: {},
+	fetchDefaultLanguage: false,
 };
 
 /* General settings */
@@ -34,6 +36,16 @@ const getLanguage = () => {
 	return initialConfig.language;
 };
 
+/**
+ * Returns if the default language, that is inlined at build time,
+ * should be fetched over the network instead.
+ * @returns {Boolean}
+ */
+const getFetchDefaultLanguage = () => {
+	initConfiguration();
+	return initialConfig.fetchDefaultLanguage;
+};
+
 const getNoConflict = () => {
 	initConfiguration();
 	return initialConfig.noConflict;
@@ -74,23 +86,36 @@ const parseConfigurationScript = () => {
 const parseURLParameters = () => {
 	const params = new URLSearchParams(window.location.search);
 
+	// Process "sap-*" params first
 	params.forEach((value, key) => {
-		if (!key.startsWith("sap-ui")) {
+		const parts = key.split("sap-").length;
+		if (parts === 0 || parts === key.split("sap-ui-").length) {
 			return;
 		}
 
-		const lowerCaseValue = value.toLowerCase();
-
-		const param = key.split("sap-ui-")[1];
+		applyURLParam(key, value, "sap");
+	});
 
-		if (booleanMapping.has(value)) {
-			value = booleanMapping.get(lowerCaseValue);
+	// Process "sap-ui-*" params
+	params.forEach((value, key) => {
+		if (!key.startsWith("sap-ui")) {
+			return;
 		}
 
-		initialConfig[param] = value;
+		applyURLParam(key, value, "sap-ui");
 	});
 };
 
+const applyURLParam = (key, value, paramType) => {
+	const lowerCaseValue = value.toLowerCase();
+	const param = key.split(`${paramType}-`)[1];
+
+	if (booleanMapping.has(value)) {
+		value = booleanMapping.get(lowerCaseValue);
+	}
+	initialConfig[param] = value;
+};
+
 const applyOpenUI5Configuration = () => {
 	const OpenUI5Support = getFeature("OpenUI5Support");
 	if (!OpenUI5Support || !OpenUI5Support.isLoaded()) {
@@ -101,7 +126,6 @@ const applyOpenUI5Configuration = () => {
 	initialConfig = merge(initialConfig, OpenUI5Config);
 };
 
-
 const initConfiguration = () => {
 	if (initialized) {
 		return;
@@ -124,6 +148,7 @@ export {
 	getTheme,
 	getRTL,
 	getLanguage,
+	getFetchDefaultLanguage,
 	getNoConflict,
 	getCalendarType,
 	getFormatSettings,

package/dist/Keys.js

@@ -0,0 +1,248 @@
+const KeyCodes = {
+	BACKSPACE: 8,
+	TAB: 9,
+	ENTER: 13,
+	SHIFT: 16,
+	CONTROL: 17,
+	ALT: 18,
+	BREAK: 19,
+	CAPS_LOCK: 20,
+	ESCAPE: 27,
+	SPACE: 32,
+	PAGE_UP: 33,
+	PAGE_DOWN: 34,
+	END: 35,
+	HOME: 36,
+	ARROW_LEFT: 37,
+	ARROW_UP: 38,
+	ARROW_RIGHT: 39,
+	ARROW_DOWN: 40,
+	PRINT: 44,
+	INSERT: 45,
+	DELETE: 46,
+	DIGIT_0: 48,
+	DIGIT_1: 49,
+	DIGIT_2: 50,
+	DIGIT_3: 51,
+	DIGIT_4: 52,
+	DIGIT_5: 53,
+	DIGIT_6: 54,
+	DIGIT_7: 55,
+	DIGIT_8: 56,
+	DIGIT_9: 57,
+	A: 65,
+	B: 66,
+	C: 67,
+	D: 68,
+	E: 69,
+	F: 70,
+	G: 71,
+	H: 72,
+	I: 73,
+	J: 74,
+	K: 75,
+	L: 76,
+	M: 77,
+	N: 78,
+	O: 79,
+	P: 80,
+	Q: 81,
+	R: 82,
+	S: 83,
+	T: 84,
+	U: 85,
+	V: 86,
+	W: 87,
+	X: 88,
+	Y: 89,
+	Z: 90,
+	WINDOWS: 91,
+	CONTEXT_MENU: 93,
+	TURN_OFF: 94,
+	SLEEP: 95,
+	NUMPAD_0: 96,
+	NUMPAD_1: 97,
+	NUMPAD_2: 98,
+	NUMPAD_3: 99,
+	NUMPAD_4: 100,
+	NUMPAD_5: 101,
+	NUMPAD_6: 102,
+	NUMPAD_7: 103,
+	NUMPAD_8: 104,
+	NUMPAD_9: 105,
+	NUMPAD_ASTERISK: 106,
+	NUMPAD_PLUS: 107,
+	NUMPAD_MINUS: 109,
+	NUMPAD_COMMA: 110,
+	NUMPAD_SLASH: 111,
+	F1: 112,
+	F2: 113,
+	F3: 114,
+	F4: 115,
+	F5: 116,
+	F6: 117,
+	F7: 118,
+	F8: 119,
+	F9: 120,
+	F10: 121,
+	F11: 122,
+	F12: 123,
+	NUM_LOCK: 144,
+	SCROLL_LOCK: 145,
+	OPEN_BRACKET: 186,
+	PLUS: 187,
+	COMMA: 188,
+	SLASH: 189,
+	DOT: 190,
+	PIPE: 191,
+	SEMICOLON: 192,
+	MINUS: 219,
+	GREAT_ACCENT: 220,
+	EQUALS: 221,
+	SINGLE_QUOTE: 222,
+	BACKSLASH: 226,
+};
+
+const isEnter = event => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && !hasModifierKeys(event);
+
+const isEnterShift = event => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && checkModifierKeys(event, false, false, true);
+
+const isSpace = event => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && !hasModifierKeys(event);
+
+const isSpaceShift = event => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && checkModifierKeys(event, false, false, true);
+
+const isLeft = event => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && !hasModifierKeys(event);
+
+const isRight = event => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && !hasModifierKeys(event);
+
+const isUp = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && !hasModifierKeys(event);
+
+const isDown = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && !hasModifierKeys(event);
+
+const isLeftCtrl = event => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, true, false, false);
+
+const isRightCtrl = event => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, true, false, false);
+
+const isUpCtrl = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, false);
+
+const isDownCtrl = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, false);
+
+const isUpShift = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, false, false, true);
+
+const isDownShift = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isLeftShift = event => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, false, false, true);
+
+const isRightShift = event => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, false, false, true);
+
+const isUpShiftCtrl = event => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, true);
+
+const isDownShiftCtrl = event => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, true);
+
+const isHome = event => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && !hasModifierKeys(event);
+
+const isEnd = event => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && !hasModifierKeys(event);
+
+const isHomeCtrl = event => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && checkModifierKeys(event, true, false, false);
+
+const isEndCtrl = event => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && checkModifierKeys(event, true, false, false);
+
+const isEscape = event => (event.key ? event.key === "Escape" || event.key === "Esc" : event.keyCode === KeyCodes.ESCAPE) && !hasModifierKeys(event);
+
+const isTabNext = event => (event.key ? event.key === "Tab" : event.keyCode === KeyCodes.TAB) && !hasModifierKeys(event);
+
+const isTabPrevious = event => (event.key ? event.key === "Tab" : event.keyCode === KeyCodes.TAB) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ false, /* Shift */ true);
+
+const isBackSpace = event => (event.key ? event.key === "Backspace" : event.keyCode === KeyCodes.BACKSPACE) && !hasModifierKeys(event);
+
+const isDelete = event => (event.key ? event.key === "Delete" : event.keyCode === KeyCodes.DELETE) && !hasModifierKeys(event);
+
+const isPageUp = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && !hasModifierKeys(event);
+
+const isPageDown = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && !hasModifierKeys(event);
+
+const isPageUpShift = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, false, true);
+
+const isPageUpAlt = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, true, false);
+
+const isPageDownShift = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isPageDownAlt = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, true, false);
+
+const isPageUpShiftCtrl = event => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, true, false, true);
+
+const isPageDownShiftCtrl = event => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, true, false, true);
+
+const isPlus = event => (event.key ? event.key === "+" : event.keyCode === KeyCodes.PLUS) || (event.keyCode === KeyCodes.NUMPAD_PLUS && !hasModifierKeys(event));
+
+const isMinus = event => (event.key ? event.key === "-" : event.keyCode === KeyCodes.MINUS) || (event.keyCode === KeyCodes.NUMPAD_MINUS && !hasModifierKeys(event));
+
+const isShow = event => {
+	if (event.key) {
+		return isF4(event) || isShowByArrows(event);
+	}
+
+	return (event.keyCode === KeyCodes.F4 && !hasModifierKeys(event)) || (event.keyCode === KeyCodes.ARROW_DOWN && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ true, /* Shift */ false));
+};
+
+const isF4 = event => {
+	return event.key === "F4" && !hasModifierKeys(event);
+};
+
+const isF4Shift = event => (event.key ? event.key === "F4" : event.keyCode === KeyCodes.F4) && checkModifierKeys(event, false, false, true);
+
+const isF7 = event => (event.key ? event.key === "F7" : event.keyCode === KeyCodes.F7) && !hasModifierKeys(event);
+
+const isShowByArrows = event => {
+	return ((event.key === "ArrowDown" || event.key === "Down") || (event.key === "ArrowUp" || event.key === "Up")) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ true, /* Shift */ false);
+};
+
+const hasModifierKeys = event => event.shiftKey || event.altKey || getCtrlKey(event);
+
+const getCtrlKey = event => !!(event.metaKey || event.ctrlKey); // double negation doesn't have effect on boolean but ensures null and undefined are equivalent to false.
+
+const checkModifierKeys = (event, bCtrlKey, bAltKey, bShiftKey) => event.shiftKey === bShiftKey && event.altKey === bAltKey && getCtrlKey(event) === bCtrlKey;
+
+export {
+	isEnter,
+	isEnterShift,
+	isSpace,
+	isSpaceShift,
+	isLeft,
+	isRight,
+	isUp,
+	isDown,
+	isLeftCtrl,
+	isRightCtrl,
+	isUpCtrl,
+	isDownCtrl,
+	isUpShift,
+	isDownShift,
+	isLeftShift,
+	isRightShift,
+	isUpShiftCtrl,
+	isDownShiftCtrl,
+	isHome,
+	isEnd,
+	isPlus,
+	isMinus,
+	isHomeCtrl,
+	isEndCtrl,
+	isEscape,
+	isTabNext,
+	isTabPrevious,
+	isBackSpace,
+	isDelete,
+	isShow,
+	isF4,
+	isF4Shift,
+	isF7,
+	isPageUp,
+	isPageDown,
+	isPageUpShift,
+	isPageUpAlt,
+	isPageDownShift,
+	isPageDownAlt,
+	isPageUpShiftCtrl,
+	isPageDownShiftCtrl,
+};

package/dist/MediaRange.js

@@ -0,0 +1,109 @@
+const querySets = {};
+
+/**
+ * Initializes a screen width media query range set.
+ *
+ * This initialization step makes the range set ready to be used for one of the other functions in namespace <code>MediaRange</code>.
+ *
+ * A range set can be defined as shown in the following example:
+ * <pre>
+ * MediaRange.initRangeSet("MyRangeSet", [200, 400], ["Small", "Medium", "Large"]);
+ * </pre>
+ * This example defines the following named ranges:
+ * <ul>
+ * <li><code>"Small"</code>: For screens smaller than 200 pixels.</li>
+ * <li><code>"Medium"</code>: For screens greater than or equal to 200 pixels and smaller than 400 pixels.</li>
+ * <li><code>"Large"</code>: For screens greater than or equal to 400 pixels.</li>
+ * </ul>
+ *
+ * @param {string} name The name of the range set to be initialized.
+ * The name must be a valid id and consist only of letters and numeric digits.
+ *
+ * @param {int[]} [borders] The range borders
+ *
+ * @param {string[]} [names] The names of the ranges. The names must be a valid id and consist only of letters and digits.
+ *
+ * @name MediaRange.initRangeSet
+ * @function
+ * @public
+ */
+const _initRangeSet = (name, borders, names) => {
+	querySets[name] = {
+		borders,
+		names,
+	};
+};
+
+/**
+ * Returns information about the current active range of the range set with the given name.
+ *
+ * If the optional parameter <code>width</code> is given, the active range will be determined for that width,
+ * otherwise it is determined for the current window size.
+ *
+ * @param {string} name The name of the range set. The range set must be initialized beforehand ({@link MediaRange.initRangeSet})
+ * @param {int} [width] An optional width, based on which the range should be determined;
+ *             If <code>width</code> is not provided, the window size will be used.
+ * @returns {string} The name of the current active interval of the range set.
+ *
+ * @name MediaRange.getCurrentRange
+ * @function
+ * @public
+ */
+const _getCurrentRange = (name, width = window.innerWidth) => {
+	const querySet = querySets[name];
+	let i = 0;
+
+	if (!querySet) {
+		return null;
+	}
+
+	for (; i < querySet.borders.length; i++) {
+		if (width < querySet.borders[i]) {
+			return querySet.names[i];
+		}
+	}
+
+	return querySet.names[i];
+};
+
+/**
+ * Enumeration containing the names and settings of predefined screen width media query range sets.
+ *
+ * @namespace
+ * @name MediaRange.RANGESETS
+ * @public
+ */
+const RANGESETS = {
+	/**
+	 * A 4-step range set (S-M-L-XL).
+	 *
+	 * The ranges of this set are:
+	 * <ul>
+	 * <li><code>"S"</code>: For screens smaller than 600 pixels.</li>
+	 * <li><code>"M"</code>: For screens greater than or equal to 600 pixels and smaller than 1024 pixels.</li>
+	 * <li><code>"L"</code>: For screens greater than or equal to 1024 pixels and smaller than 1440 pixels.</li>
+	 * <li><code>"XL"</code>: For screens greater than or equal to 1440 pixels.</li>
+	 * </ul>
+	 *
+	 * @name MediaRange.RANGESETS.RANGE_4STEPS
+	 * @public
+	 */
+	RANGE_4STEPS: "4Step",
+};
+
+/**
+ * API for screen width changes.
+ *
+ * @namespace
+ * @name MediaRange
+ */
+
+const MediaRange = {
+	RANGESETS,
+	initRangeSet: _initRangeSet,
+	getCurrentRange: _getCurrentRange,
+};
+
+MediaRange.initRangeSet(MediaRange.RANGESETS.RANGE_4STEPS, [600, 1024, 1440], ["S", "M", "L", "XL"]);
+
+export default MediaRange;