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

package/src/{CustomElementsScopeUtils.js → CustomElementsScopeUtils.ts}

@@ -1,9 +1,16 @@
-let suf;
-let rulesObj = {
+let suf: string;
+
+type Rules = {
+	include: Array<RegExp>,
+	exclude: Array<RegExp>,
+};
+
+let rulesObj: Rules = {
 	include: [/^ui5-/],
 	exclude: [],
 };
-const tagsCache = new Map(); // true/false means the tag should/should not be cached, undefined means not known yet.
+
+const tagsCache = new Map<string, boolean>(); // true/false means the tag should/should not be cached, undefined means not known yet.
 
 /**
  * Sets the suffix to be used for custom elements scoping, f.e. pass "demo" to get tags such as "ui5-button-demo".
@@ -12,7 +19,7 @@ const tagsCache = new Map(); // true/false means the tag should/should not be ca
  * @public
  * @param suffix The scoping suffix
  */
-const setCustomElementsScopingSuffix = suffix => {
+const setCustomElementsScopingSuffix = (suffix: string) => {
 	if (!suffix.match(/^[a-zA-Z0-9_-]+$/)) {
 		throw new Error("Only alphanumeric characters and dashes allowed for the scoping suffix");
 	}
@@ -39,7 +46,7 @@ const getCustomElementsScopingSuffix = () => {
  * @param rules Object with "include" and "exclude" properties, both arrays of regular expressions. Note that "include"
  * rules are applied first and "exclude" rules second.
  */
-const setCustomElementsScopingRules = rules => {
+const setCustomElementsScopingRules = (rules: Rules) => {
 	if (!rules || !rules.include) {
 		throw new Error(`"rules" must be an object with at least an "include" property`);
 	}
@@ -76,7 +83,7 @@ const getCustomElementsScopingRules = () => {
  * @public
  * @param tag
  */
-const shouldScopeCustomElement = tag => {
+const shouldScopeCustomElement = (tag: string) => {
 	if (!tagsCache.has(tag)) {
 		const result = rulesObj.include.some(rule => tag.match(rule)) && !rulesObj.exclude.some(rule => tag.match(rule));
 		tagsCache.set(tag, result);
@@ -92,7 +99,7 @@ const shouldScopeCustomElement = tag => {
  * @param tag
  * @returns {String}
  */
-const getEffectiveScopingSuffixForTag = tag => {
+const getEffectiveScopingSuffixForTag = (tag: string) => {
 	if (shouldScopeCustomElement(tag)) {
 		return getCustomElementsScopingSuffix();
 	}

package/src/DOMObserver.ts

@@ -0,0 +1,28 @@
+const observers = new WeakMap<Node, MutationObserver>();
+
+/**
+ * @param node
+ * @param callback
+ * @param options
+ */
+const observeDOMNode = (node: Node, callback: MutationCallback, options?: MutationObserverInit) => {
+	const observer = new MutationObserver(callback);
+	observers.set(node, observer);
+	observer.observe(node, options);
+};
+
+/**
+ * @param node
+ */
+const unobserveDOMNode = (node: Node) => {
+	const observer = observers.get(node);
+	if (observer) {
+		observer.disconnect();
+		observers.delete(node);
+	}
+};
+
+export {
+	observeDOMNode,
+	unobserveDOMNode,
+};

package/src/{Device.js → Device.ts}

@@ -2,10 +2,11 @@ const ua = navigator.userAgent;
 const touch = "ontouchstart" in window || navigator.maxTouchPoints > 0;
 const ie = /(msie|trident)/i.test(ua);
 const chrome = !ie && /(Chrome|CriOS)/.test(ua);
+const firefox = /Firefox/.test(ua);
 const safari = !ie && !chrome && /(Version|PhantomJS)\/(\d+\.\d+).*Safari/.test(ua);
 const webkit = !ie && /webkit/.test(ua);
 const windows = navigator.platform.indexOf("Win") !== -1;
-const iOS = navigator.platform.match(/iPhone|iPad|iPod/) || (navigator.userAgent.match(/Mac/) && "ontouchend" in document);
+const iOS = !!(navigator.platform.match(/iPhone|iPad|iPod/)) || !!(navigator.userAgent.match(/Mac/) && "ontouchend" in document);
 const android = !windows && /Android/.test(ua);
 const androidPhone = android && /(?=android)(?=.*mobile)/i.test(ua);
 const ipad = /ipad/i.test(ua) || (/Macintosh/i.test(ua) && "ontouchend" in document);
@@ -13,9 +14,9 @@ const ipad = /ipad/i.test(ua) || (/Macintosh/i.test(ua) && "ontouchend" in docum
 // "Request Desktop Website -> All websites" (for more infos see: https://forums.developer.apple.com/thread/119186).
 // Therefore the OS is detected as MACINTOSH instead of iOS and the device is a tablet if the Device.support.touch is true.
 
-let windowsVersion;
-let webkitVersion;
-let tablet;
+let windowsVersion: number;
+let webkitVersion: number;
+let tablet: boolean;
 
 const isWindows8OrAbove = () => {
 	if (!windows) {
@@ -76,34 +77,35 @@ const detectTablet = () => {
 	tablet = (ie && ua.indexOf("Touch") !== -1) || (android && !androidPhone);
 };
 
-const supportsTouch = () => touch;
-const isIE = () => ie;
-const isSafari = () => safari;
-const isChrome = () => chrome;
+const supportsTouch = (): boolean => touch;
+const isIE = (): boolean => ie;
+const isSafari = (): boolean => safari;
+const isChrome = (): boolean => chrome;
+const isFirefox = (): boolean => firefox;
 
-const isTablet = () => {
+const isTablet = (): boolean => {
 	detectTablet();
 	return (touch || isWindows8OrAbove()) && tablet;
 };
 
-const isPhone = () => {
+const isPhone = (): boolean => {
 	detectTablet();
 	return touch && !tablet;
 };
 
-const isDesktop = () => {
+const isDesktop = (): boolean => {
 	return (!isTablet() && !isPhone()) || isWindows8OrAbove();
 };
 
-const isCombi = () => {
+const isCombi = (): boolean => {
 	return isTablet() && isDesktop();
 };
 
-const isIOS = () => {
+const isIOS = (): boolean => {
 	return iOS;
 };
 
-const isAndroid = () => {
+const isAndroid = (): boolean => {
 	return android || androidPhone;
 };
 
@@ -112,6 +114,7 @@ export {
 	isIE,
 	isSafari,
 	isChrome,
+	isFirefox,
 	isPhone,
 	isTablet,
 	isDesktop,

package/src/{EventProvider.js → EventProvider.ts}

@@ -1,9 +1,11 @@
-class EventProvider {
+class EventProvider<EventListenerParam, EventListenerReturn> {
+	_eventRegistry: Map<string, Array<(param: EventListenerParam) => EventListenerReturn>>;
+
 	constructor() {
 		this._eventRegistry = new Map();
 	}
 
-	attachEvent(eventName, fnFunction) {
+	attachEvent(eventName: string, fnFunction: (param: EventListenerParam) => EventListenerReturn) {
 		const eventRegistry = this._eventRegistry;
 		const eventListeners = eventRegistry.get(eventName);
 
@@ -17,7 +19,7 @@ class EventProvider {
 		}
 	}
 
-	detachEvent(eventName, fnFunction) {
+	detachEvent(eventName: string, fnFunction: (param: EventListenerParam) => EventListenerReturn) {
 		const eventRegistry = this._eventRegistry;
 		const eventListeners = eventRegistry.get(eventName);
 
@@ -42,7 +44,7 @@ class EventProvider {
 	 * @param data optional data to pass to each event listener
 	 * @returns {Array} an array with the results of all event listeners
 	 */
-	fireEvent(eventName, data) {
+	fireEvent(eventName: string, data: EventListenerParam) {
 		const eventRegistry = this._eventRegistry;
 		const eventListeners = eventRegistry.get(eventName);
 
@@ -62,11 +64,11 @@ class EventProvider {
 	 * @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) {
+	fireEventAsync(eventName: string, data: EventListenerParam) {
 		return Promise.all(this.fireEvent(eventName, data));
 	}
 
-	isHandlerAttached(eventName, fnFunction) {
+	isHandlerAttached(eventName: string, fnFunction: (param: EventListenerParam) => EventListenerReturn) {
 		const eventRegistry = this._eventRegistry;
 		const eventListeners = eventRegistry.get(eventName);
 
@@ -77,7 +79,7 @@ class EventProvider {
 		return eventListeners.includes(fnFunction);
 	}
 
-	hasListeners(eventName) {
+	hasListeners(eventName: string) {
 		return !!this._eventRegistry.get(eventName);
 	}
 }

package/src/FeaturesRegistry.ts

@@ -0,0 +1,14 @@
+const features = new Map<string, any>();
+
+const registerFeature = (name: string, feature: object) => {
+	features.set(name, feature);
+};
+
+const getFeature = <T>(name: string): T => {
+	return features.get(name) as T;
+};
+
+export {
+	registerFeature,
+	getFeature,
+};

package/src/{FontFace.js → FontFace.ts}

@@ -2,12 +2,13 @@ import { hasStyle, createStyle } from "./ManagedStyles.js";
 import { getFeature } from "./FeaturesRegistry.js";
 import fontFaceCSS from "./generated/css/FontFace.css.js";
 import overrideFontFaceCSS from "./generated/css/OverrideFontFace.css.js";
+import type OpenUI5Support from "./features/OpenUI5Support.js";
 
 const insertFontFace = () => {
-	const OpenUI5Support = getFeature("OpenUI5Support");
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
 
 	// Only set the main font if there is no OpenUI5 support, or there is, but OpenUI5 is not loaded
-	if (!OpenUI5Support || !OpenUI5Support.isLoaded()) {
+	if (!openUI5Support || !openUI5Support.isLoaded()) {
 		insertMainFontFace();
 	}
 

package/src/{InitialConfiguration.js → InitialConfiguration.ts}

@@ -1,15 +1,34 @@
 import merge from "./thirdparty/merge.js";
 import { getFeature } from "./FeaturesRegistry.js";
 import { DEFAULT_THEME } from "./generated/AssetParameters.js";
+import validateThemeRoot from "./validateThemeRoot.js";
+import type OpenUI5Support from "./features/OpenUI5Support";
+import type { FormatSettings } from "./config/FormatSettings.js";
+import AnimationMode from "./types/AnimationMode.js";
+import CalendarType from "./types/CalendarType.js";
 
 let initialized = false;
 
-let initialConfig = {
-	animationMode: "full",
+type InitialConfig = {
+	[key: string]: any,
+	animationMode: AnimationMode,
+	theme: string,
+	themeRoot: string | undefined,
+	rtl: boolean | undefined,
+	language: string | undefined,
+	calendarType: CalendarType | undefined,
+	noConflict: boolean,
+	formatSettings: FormatSettings,
+	fetchDefaultLanguage: boolean,
+};
+
+let initialConfig: InitialConfig = {
+	animationMode: AnimationMode.Full,
 	theme: DEFAULT_THEME,
-	rtl: null,
-	language: null,
-	calendarType: null,
+	themeRoot: undefined,
+	rtl: undefined,
+	language: undefined,
+	calendarType: undefined,
 	noConflict: false, // no URL
 	formatSettings: {},
 	fetchDefaultLanguage: false,
@@ -26,6 +45,11 @@ const getTheme = () => {
 	return initialConfig.theme;
 };
 
+const getThemeRoot = () => {
+	initConfiguration();
+	return initialConfig.themeRoot;
+};
+
 const getRTL = () => {
 	initConfiguration();
 	return initialConfig.rtl;
@@ -51,6 +75,10 @@ const getNoConflict = () => {
 	return initialConfig.noConflict;
 };
 
+/**
+ * Get the configured calendar type
+ * @returns { String } the name of the configured calendar type
+ */
 const getCalendarType = () => {
 	initConfiguration();
 	return initialConfig.calendarType;
@@ -106,7 +134,13 @@ const parseURLParameters = () => {
 	});
 };
 
-const normalizeParamValue = (param, value) => {
+const normalizeThemeRootParamValue = (value: string) => {
+	const themeRoot = value.split("@")[1];
+
+	return validateThemeRoot(themeRoot);
+};
+
+const normalizeThemeParamValue = (param: string, value: string) => {
 	if (param === "theme" && value.includes("@")) { // the theme parameter might have @<URL-TO-THEME> in the value - strip this
 		return value.split("@")[0];
 	}
@@ -114,7 +148,7 @@ const normalizeParamValue = (param, value) => {
 	return value;
 };
 
-const applyURLParam = (key, value, paramType) => {
+const applyURLParam = (key: string, value: string, paramType: string) => {
 	const lowerCaseValue = value.toLowerCase();
 	const param = key.split(`${paramType}-`)[1];
 
@@ -122,18 +156,24 @@ const applyURLParam = (key, value, paramType) => {
 		value = booleanMapping.get(lowerCaseValue);
 	}
 
-	value = normalizeParamValue(param, value);
+	if (param === "theme") {
+		initialConfig.theme = normalizeThemeParamValue(param, value);
 
-	initialConfig[param] = value;
+		if (value && value.includes("@")) {
+			initialConfig.themeRoot = normalizeThemeRootParamValue(value);
+		}
+	} else {
+		initialConfig[param] = value;
+	}
 };
 
 const applyOpenUI5Configuration = () => {
-	const OpenUI5Support = getFeature("OpenUI5Support");
-	if (!OpenUI5Support || !OpenUI5Support.isLoaded()) {
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
+	if (!openUI5Support || !openUI5Support.isLoaded()) {
 		return;
 	}
 
-	const OpenUI5Config = OpenUI5Support.getConfigurationSettingsObject();
+	const OpenUI5Config = openUI5Support.getConfigurationSettingsObject();
 	initialConfig = merge(initialConfig, OpenUI5Config);
 };
 
@@ -157,6 +197,7 @@ const initConfiguration = () => {
 export {
 	getAnimationMode,
 	getTheme,
+	getThemeRoot,
 	getRTL,
 	getLanguage,
 	getFetchDefaultLanguage,

package/src/Keys.ts

@@ -0,0 +1,295 @@
+enum 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: KeyboardEvent): boolean => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && !hasModifierKeys(event);
+
+const isEnterShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "Enter" : event.keyCode === KeyCodes.ENTER) && checkModifierKeys(event, false, false, true);
+
+const isSpace = (event: KeyboardEvent): boolean => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && !hasModifierKeys(event);
+
+const isSpaceShift = (event: KeyboardEvent): boolean => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && checkModifierKeys(event, false, false, true);
+
+const isSpaceCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "Spacebar" || event.key === " ") : event.keyCode === KeyCodes.SPACE) && checkModifierKeys(event, true, false, false);
+
+const isLeft = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && !hasModifierKeys(event);
+
+const isRight = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && !hasModifierKeys(event);
+
+const isUp = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && !hasModifierKeys(event);
+
+const isDown = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && !hasModifierKeys(event);
+
+const isLeftCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, true, false, false);
+
+const isRightCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, true, false, false);
+
+const isUpCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, false);
+
+const isDownCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, false);
+
+const isUpShift = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, false, false, true);
+
+const isDownShift = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isUpAlt = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, false, true, false);
+
+const isDownAlt = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, false, true, false);
+
+const isLeftShift = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, false, false, true);
+
+const isRightShift = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, false, false, true);
+
+const isLeftShiftCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowLeft" || event.key === "Left") : event.keyCode === KeyCodes.ARROW_LEFT) && checkModifierKeys(event, true, false, true);
+
+const isRightShiftCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowRight" || event.key === "Right") : event.keyCode === KeyCodes.ARROW_RIGHT) && checkModifierKeys(event, true, false, true);
+
+const isUpShiftCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, false, true);
+
+const isDownShiftCtrl = (event: KeyboardEvent): boolean => (event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, false, true);
+
+const isHome = (event: KeyboardEvent): boolean => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && !hasModifierKeys(event);
+
+const isEnd = (event: KeyboardEvent): boolean => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && !hasModifierKeys(event);
+
+const isHomeCtrl = (event: KeyboardEvent): boolean => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && checkModifierKeys(event, true, false, false);
+
+const isHomeShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "Home" : event.keyCode === KeyCodes.HOME) && checkModifierKeys(event, false, false, true);
+
+const isEndCtrl = (event: KeyboardEvent): boolean => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && checkModifierKeys(event, true, false, false);
+
+const isEndShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "End" : event.keyCode === KeyCodes.END) && checkModifierKeys(event, false, false, true);
+
+const isEscape = (event: KeyboardEvent): boolean => (event.key ? event.key === "Escape" || event.key === "Esc" : event.keyCode === KeyCodes.ESCAPE) && !hasModifierKeys(event);
+
+const isTabNext = (event: KeyboardEvent): boolean => (event.key ? event.key === "Tab" : event.keyCode === KeyCodes.TAB) && !hasModifierKeys(event);
+
+const isTabPrevious = (event: KeyboardEvent): boolean => (event.key ? event.key === "Tab" : event.keyCode === KeyCodes.TAB) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ false, /* Shift */ true);
+
+const isBackSpace = (event: KeyboardEvent): boolean => (event.key ? event.key === "Backspace" : event.keyCode === KeyCodes.BACKSPACE) && !hasModifierKeys(event);
+
+const isDelete = (event: KeyboardEvent): boolean => (event.key ? event.key === "Delete" : event.keyCode === KeyCodes.DELETE) && !hasModifierKeys(event);
+
+const isDeleteShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "Delete" : event.keyCode === KeyCodes.DELETE) && checkModifierKeys(event, false, false, true);
+
+const isInsertShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "Insert" : event.keyCode === KeyCodes.DELETE) && checkModifierKeys(event, false, false, true);
+
+const isInsertCtrl = (event: KeyboardEvent): boolean => (event.key ? event.key === "Insert" : event.keyCode === KeyCodes.DELETE) && checkModifierKeys(event, true, false, false);
+
+const isPageUp = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && !hasModifierKeys(event);
+
+const isPageDown = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && !hasModifierKeys(event);
+
+const isPageUpShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, false, true);
+
+const isPageUpAlt = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, false, true, false);
+
+const isPageDownShift = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, false, true);
+
+const isPageDownAlt = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, false, true, false);
+
+const isPageUpShiftCtrl = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageUp" : event.keyCode === KeyCodes.PAGE_UP) && checkModifierKeys(event, true, false, true);
+
+const isPageDownShiftCtrl = (event: KeyboardEvent): boolean => (event.key ? event.key === "PageDown" : event.keyCode === KeyCodes.PAGE_DOWN) && checkModifierKeys(event, true, false, true);
+
+const isPlus = (event: KeyboardEvent): boolean => (event.key ? event.key === "+" : event.keyCode === KeyCodes.PLUS) || (event.keyCode === KeyCodes.NUMPAD_PLUS && !hasModifierKeys(event));
+
+const isMinus = (event: KeyboardEvent): boolean => (event.key ? event.key === "-" : event.keyCode === KeyCodes.MINUS) || (event.keyCode === KeyCodes.NUMPAD_MINUS && !hasModifierKeys(event));
+
+const isShow = (event: KeyboardEvent): boolean => {
+	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: KeyboardEvent): boolean => {
+	return event.key === "F4" && !hasModifierKeys(event);
+};
+
+const isF4Shift = (event: KeyboardEvent): boolean => (event.key ? event.key === "F4" : event.keyCode === KeyCodes.F4) && checkModifierKeys(event, false, false, true);
+
+const isF6Next = (event: KeyboardEvent): boolean => ((event.key ? event.key === "F6" : event.keyCode === KeyCodes.F6) && checkModifierKeys(event, false, false, false))
+	|| ((event.key ? (event.key === "ArrowDown" || event.key === "Down") : event.keyCode === KeyCodes.ARROW_DOWN) && checkModifierKeys(event, true, true, false));
+
+const isF6Previous = (event: KeyboardEvent): boolean => ((event.key ? event.key === "F6" : event.keyCode === KeyCodes.F6) && checkModifierKeys(event, false, false, true))
+	|| ((event.key ? (event.key === "ArrowUp" || event.key === "Up") : event.keyCode === KeyCodes.ARROW_UP) && checkModifierKeys(event, true, true, false));
+
+const isF7 = (event: KeyboardEvent): boolean => (event.key ? event.key === "F7" : event.keyCode === KeyCodes.F7) && !hasModifierKeys(event);
+
+const isShowByArrows = (event: KeyboardEvent): boolean => {
+	return ((event.key === "ArrowDown" || event.key === "Down") || (event.key === "ArrowUp" || event.key === "Up")) && checkModifierKeys(event, /* Ctrl */ false, /* Alt */ true, /* Shift */ false);
+};
+
+const isShift = (event: KeyboardEvent): boolean => event.key === "Shift" || event.keyCode === KeyCodes.SHIFT;
+
+const isCtrlA = (event: KeyboardEvent): boolean => ((event.key === "A" || event.key === "a") || event.which === KeyCodes.A) && checkModifierKeys(event, true, false, false);
+
+const isCtrlV = (event: KeyboardEvent): boolean => ((event.key === "V" || event.key === "v") || event.which === KeyCodes.V) && checkModifierKeys(event, true, false, false);
+
+const hasModifierKeys = (event: KeyboardEvent): boolean => event.shiftKey || event.altKey || getCtrlKey(event);
+
+const getCtrlKey = (event: KeyboardEvent): boolean => !!(event.metaKey || event.ctrlKey); // double negation doesn't have effect on boolean but ensures null and undefined are equivalent to false.
+
+const checkModifierKeys = (event: KeyboardEvent, bCtrlKey: boolean, bAltKey: boolean, bShiftKey: boolean):boolean => event.shiftKey === bShiftKey && event.altKey === bAltKey && getCtrlKey(event) === bCtrlKey;
+
+export {
+	isEnter,
+	isEnterShift,
+	isSpace,
+	isSpaceShift,
+	isSpaceCtrl,
+	isLeft,
+	isRight,
+	isUp,
+	isDown,
+	isLeftCtrl,
+	isRightCtrl,
+	isUpCtrl,
+	isDownCtrl,
+	isUpShift,
+	isDownShift,
+	isUpAlt,
+	isDownAlt,
+	isLeftShift,
+	isRightShift,
+	isLeftShiftCtrl,
+	isRightShiftCtrl,
+	isUpShiftCtrl,
+	isDownShiftCtrl,
+	isHome,
+	isEnd,
+	isPlus,
+	isMinus,
+	isHomeCtrl,
+	isEndCtrl,
+	isHomeShift,
+	isEndShift,
+	isEscape,
+	isTabNext,
+	isTabPrevious,
+	isBackSpace,
+	isDelete,
+	isShow,
+	isF4,
+	isF4Shift,
+	isF6Previous,
+	isF6Next,
+	isF7,
+	isPageUp,
+	isPageDown,
+	isPageUpShift,
+	isPageUpAlt,
+	isPageDownShift,
+	isPageDownAlt,
+	isPageUpShiftCtrl,
+	isPageDownShiftCtrl,
+	isShift,
+	isCtrlA,
+	isCtrlV,
+	isDeleteShift,
+	isInsertShift,
+	isInsertCtrl,
+};