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

package/dist/generated/css/FontFace.css.js

@@ -0,0 +1,5 @@
+export default {
+	packageName: "@ui5/webcomponents-base",
+	fileName: "FontFace.css",
+	content: `@font-face{font-family:"72";font-style:normal;font-weight:400;src:local("72"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Regular.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Regular.woff?ui5-webcomponents) format("woff")}@font-face{font-family:"72full";font-style:normal;font-weight:400;src:local('72-full'),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Regular-full.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Regular-full.woff?ui5-webcomponents) format("woff")}@font-face{font-family:"72";font-style:normal;font-weight:700;src:local('72-Bold'),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold.woff?ui5-webcomponents) format("woff")}@font-face{font-family:"72full";font-style:normal;font-weight:700;src:local('72-Bold-full'),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold-full.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold-full.woff?ui5-webcomponents) format("woff")}@font-face{font-family:'72-Bold';font-style:normal;src:local('72-Bold'),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold.woff?ui5-webcomponents) format("woff")}@font-face{font-family:'72-Boldfull';font-style:normal;src:url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold-full.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Bold-full.woff?ui5-webcomponents) format("woff")}@font-face{font-family:'72-Light';font-style:normal;src:local('72-Light'),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Light.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Light.woff?ui5-webcomponents) format("woff")}@font-face{font-family:'72-Lightfull';font-style:normal;src:url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Light-full.woff2?ui5-webcomponents) format("woff2"),url(https://ui5.sap.com/resources/sap/ui/core/themes/sap_fiori_3/fonts/72-Light-full.woff?ui5-webcomponents) format("woff")}@font-face{font-family:"72Black";font-style:bold;font-weight:900;src:local('72Black'),url(https://openui5nightly.hana.ondemand.com/resources/sap/ui/core/themes/sap_horizon/fonts/72-Black.woff2?ui5-webcomponents) format("woff2"),url(https://openui5nightly.hana.ondemand.com/resources/sap/ui/core/themes/sap_horizon/fonts/72-Black.woff?ui5-webcomponents) format("woff")}`
+};

package/dist/generated/css/OverrideFontFace.css.js

@@ -0,0 +1,5 @@
+export default {
+	packageName: "@ui5/webcomponents-base",
+	fileName: "OverrideFontFace.css",
+	content: `@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')}`
+};

package/dist/generated/css/SystemCSSVars.css.js

@@ -0,0 +1,5 @@
+export default {
+	packageName: "@ui5/webcomponents-base",
+	fileName: "SystemCSSVars.css",
+	content: `:root{--_ui5_content_density:cozy}.sapUiSizeCompact,.ui5-content-density-compact,[data-ui5-compact-size]{--_ui5_content_density:compact}[dir=rtl]{--_ui5_dir:rtl}[dir=ltr]{--_ui5_dir:ltr}`
+};

package/dist/i18nBundle.js

@@ -1,8 +1,10 @@
-import { registerI18nBundle, 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();
 
+let customGetI18nBundle;
+
 /**
  * @class
  * @public
@@ -15,6 +17,7 @@ class I18nBundle {
 	/**
 	 * 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 {*}
@@ -29,13 +32,16 @@ class I18nBundle {
 		}
 
 		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(messageText, params);
 	}
 }
 
-const getI18nBundle = packageName => {
+const getI18nBundleSync = packageName => {
 	if (I18nBundleInstances.has(packageName)) {
 		return I18nBundleInstances.get(packageName);
 	}
@@ -45,8 +51,36 @@ const getI18nBundle = packageName => {
 	return i18nBundle;
 };
 
+/**
+ * Allows developers to provide a custom getI18nBundle implementation
+ * If this function is called, the custom implementation will be used for all components and will completely
+ * replace the default implementation.
+ *
+ * @public
+ * @param customGet the function to use instead of the standard getI18nBundle implementation
+ */
+const registerCustomI18nBundleGetter = customGet => {
+	customGetI18nBundle = customGet;
+};
+
+/**
+ * Fetches and returns the I18nBundle instance for the given package
+ *
+ * @public
+ * @param packageName
+ * @returns {Promise<I18nBundle>}
+ */
+const getI18nBundle = async packageName => {
+	if (customGetI18nBundle) {
+		return customGetI18nBundle(packageName);
+	}
+
+	await fetchI18nBundle(packageName);
+	return getI18nBundleSync(packageName);
+};
+
 export {
-	registerI18nBundle,
-	fetchI18nBundle,
+	registerI18nLoader,
 	getI18nBundle,
+	registerCustomI18nBundleGetter,
 };

package/dist/locale/applyDirection.js

@@ -1,4 +1,5 @@
-import RenderScheduler from "../RenderScheduler.js";
+import { reRenderAllUI5Elements } from "../Render.js";
+import { fireDirectionChange } from "./directionChange.js";
 
 /**
  * Re-renders all RTL-aware UI5 Elements.
@@ -7,9 +8,10 @@ import RenderScheduler from "../RenderScheduler.js";
  *
  * @returns {Promise<void>}
  */
-const applyDirection = () => {
-	RenderScheduler.reRenderAllUI5Elements({ rtlAware: true });
-	return RenderScheduler.whenFinished();
+const applyDirection = async () => {
+	const listenersResults = fireDirectionChange();
+	await Promise.all(listenersResults);
+	await reRenderAllUI5Elements({ rtlAware: true });
 };
 
 export default applyDirection;

package/dist/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/dist/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/dist/locale/languageChange.js

@@ -12,7 +12,7 @@ const detachLanguageChange = listener => {
 };
 
 const fireLanguageChange = lang => {
-	return eventProvider.fireEvent(LANG_CHANGE, lang);
+	return eventProvider.fireEventAsync(LANG_CHANGE, lang);
 };
 
 export {

package/dist/renderer/LitRenderer.js

@@ -1,31 +1,52 @@
-import { html, svg, render } from "lit-html/lit-html.js";
-import scopeHTML from "./scopeHTML.js";
+import {
+	render,
+	html,
+	svg,
+} from "lit-html";
+import { getFeature } from "../FeaturesRegistry.js";
 
-let tags;
-let	suffix;
-
-const setTags = t => {
-	tags = t;
+const effectiveHtml = (...args) => {
+	const LitStatic = getFeature("LitStatic");
+	const fn = LitStatic ? LitStatic.html : html;
+	return fn(...args);
 };
-const setSuffix = s => {
-	suffix = s;
+
+const effectiveSvg = (...args) => {
+	const LitStatic = getFeature("LitStatic");
+	const fn = LitStatic ? LitStatic.svg : svg;
+	return fn(...args);
 };
 
-const litRender = (templateResult, domNode, styles, { eventContext } = {}) => {
-	if (styles) {
-		templateResult = html`<style>${styles}</style>${templateResult}`;
+const litRender = (templateResult, domNode, styleStrOrHrefsArr, forStaticArea, { host } = {}) => {
+	const OpenUI5Enablement = getFeature("OpenUI5Enablement");
+	if (OpenUI5Enablement && !forStaticArea) {
+		templateResult = OpenUI5Enablement.wrapTemplateResultInBusyMarkup(effectiveHtml, host, templateResult);
+	}
+
+	if (typeof styleStrOrHrefsArr === "string") {
+		templateResult = effectiveHtml`<style>${styleStrOrHrefsArr}</style>${templateResult}`;
+	} else if (Array.isArray(styleStrOrHrefsArr) && styleStrOrHrefsArr.length) {
+		templateResult = effectiveHtml`${styleStrOrHrefsArr.map(href => effectiveHtml`<link type="text/css" rel="stylesheet" href="${href}">`)}${templateResult}`;
 	}
-	render(templateResult, domNode, { eventContext });
+	render(templateResult, domNode, { host });
 };
 
-const scopedHtml = (strings, ...values) => html(scopeHTML(strings, tags, suffix), ...values);
-const scopedSvg = (strings, ...values) => svg(scopeHTML(strings, tags, suffix), ...values);
+const scopeTag = (tag, tags, suffix) => {
+	const LitStatic = getFeature("LitStatic");
+	if (LitStatic) {
+		return LitStatic.unsafeStatic((tags || []).includes(tag) ? `${tag}-${suffix}` : tag);
+	}
+};
 
-export { setTags, setSuffix };
-export { scopedHtml as html, scopedSvg as svg };
+export {
+	effectiveHtml as html,
+	effectiveSvg as svg,
+};
+export { scopeTag };
 export { repeat } from "lit-html/directives/repeat.js";
 export { classMap } from "lit-html/directives/class-map.js";
-export { styleMap } from "lit-html/directives/style-map.js";
+export { styleMap } from "./directives/style-map.js";
+export { ifDefined } from "lit-html/directives/if-defined.js";
 export { unsafeHTML } from "lit-html/directives/unsafe-html.js";
 
 export default litRender;

package/dist/renderer/directives/style-map.js

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * This is the original style-map.js directive from lit-html 2 with the only difference that "render" is not called even for the first rendering (update is used instead)
+ */
+
+import { noChange } from 'lit-html';
+import { directive, Directive, PartType, } from 'lit-html/directive.js';
+class StyleMapDirective extends Directive {
+	constructor(partInfo) {
+		var _a;
+		super(partInfo);
+		if (partInfo.type !== PartType.ATTRIBUTE ||
+			partInfo.name !== 'style' ||
+			((_a = partInfo.strings) === null || _a === void 0 ? void 0 : _a.length) > 2) {
+			throw new Error('The `styleMap` directive must be used in the `style` attribute ' +
+				'and must be the only part in the attribute.');
+		}
+	}
+	render(styleInfo) {
+		return "";
+	}
+	update(part, [styleInfo]) {
+		const { style } = part.element;
+		if (this._previousStyleProperties === undefined) {
+			this._previousStyleProperties = new Set();
+			for (const name in styleInfo) {
+				this._previousStyleProperties.add(name);
+			}
+			// return this.render(styleInfo);
+		}
+		// Remove old properties that no longer exist in styleInfo
+		// We use forEach() instead of for-of so that re don't require down-level
+		// iteration.
+		this._previousStyleProperties.forEach((name) => {
+			// If the name isn't in styleInfo or it's null/undefined
+			if (styleInfo[name] == null) {
+				this._previousStyleProperties.delete(name);
+				if (name.includes('-')) {
+					style.removeProperty(name);
+				}
+				else {
+					// Note reset using empty string (vs null) as IE11 does not always
+					// reset via null (https://developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style#setting_styles)
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					style[name] = '';
+				}
+			}
+		});
+		// Add or update properties
+		for (const name in styleInfo) {
+			const value = styleInfo[name];
+			if (value != null) {
+				this._previousStyleProperties.add(name);
+				if (name.includes('-')) {
+					style.setProperty(name, value);
+				}
+				else {
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					style[name] = value;
+				}
+			}
+		}
+		return noChange;
+	}
+}
+
+export const styleMap = directive(StyleMapDirective);

package/dist/renderer/executeTemplate.js

@@ -1,4 +1,4 @@
-import { getCustomElementsScopingSuffix, shouldScopeCustomElement } from "../CustomElementsScope.js";
+import { getCustomElementsScopingSuffix, shouldScopeCustomElement } from "../CustomElementsScopeUtils.js";
 
 /**
  * Runs a component's template with the component's current state, while also scoping HTML
@@ -9,9 +9,26 @@ import { getCustomElementsScopingSuffix, shouldScopeCustomElement } from "../Cus
  * @returns {*}
  */
 const executeTemplate = (template, component) => {
-	const tagsToScope = component.constructor.getUniqueDependencies().map(dep => dep.getMetadata().getPureTag()).filter(shouldScopeCustomElement);
+	const tagsToScope = getTagsToScope(component);
 	const scope = getCustomElementsScopingSuffix();
 	return template(component, tagsToScope, scope);
 };
 
+/**
+ * Returns all tags, used inside component's template subject to scoping.
+ * @param component - the component
+ * @returns {Array[]}
+ * @private
+ */
+const getTagsToScope = component => {
+	const componentTag = component.constructor.getMetadata().getPureTag();
+	const tagsToScope = component.constructor.getUniqueDependencies().map(dep => dep.getMetadata().getPureTag()).filter(shouldScopeCustomElement);
+
+	if (shouldScopeCustomElement(componentTag)) {
+		tagsToScope.push(componentTag);
+	}
+
+	return tagsToScope;
+};
+
 export default executeTemplate;

package/dist/sap/base/Log.js

@@ -0,0 +1,241 @@
+import now from './util/now.js';
+var Log = {};
+Log.Level = {
+    NONE: -1,
+    FATAL: 0,
+    ERROR: 1,
+    WARNING: 2,
+    INFO: 3,
+    DEBUG: 4,
+    TRACE: 5,
+    ALL: 5 + 1
+};
+var sDefaultComponent, aLog = [], mMaxLevel = { '': Log.Level.ERROR }, iLogEntriesLimit = 3000, oListener = null, bLogSupportInfo = false;
+function pad0(i, w) {
+    return ('000' + String(i)).slice(-w);
+}
+function level(sComponent) {
+    return !sComponent || isNaN(mMaxLevel[sComponent]) ? mMaxLevel[''] : mMaxLevel[sComponent];
+}
+function discardLogEntries() {
+    var iLogLength = aLog.length;
+    if (iLogLength) {
+        var iEntriesToKeep = Math.min(iLogLength, Math.floor(iLogEntriesLimit * 0.7));
+        if (oListener) {
+            oListener.onDiscardLogEntries(aLog.slice(0, iLogLength - iEntriesToKeep));
+        }
+        if (iEntriesToKeep) {
+            aLog = aLog.slice(-iEntriesToKeep, iLogLength);
+        } else {
+            aLog = [];
+        }
+    }
+}
+function getLogEntryListenerInstance() {
+    if (!oListener) {
+        oListener = {
+            listeners: [],
+            onLogEntry: function (oLogEntry) {
+                for (var i = 0; i < oListener.listeners.length; i++) {
+                    if (oListener.listeners[i].onLogEntry) {
+                        oListener.listeners[i].onLogEntry(oLogEntry);
+                    }
+                }
+            },
+            onDiscardLogEntries: function (aDiscardedLogEntries) {
+                for (var i = 0; i < oListener.listeners.length; i++) {
+                    if (oListener.listeners[i].onDiscardLogEntries) {
+                        oListener.listeners[i].onDiscardLogEntries(aDiscardedLogEntries);
+                    }
+                }
+            },
+            attach: function (oLog, oLstnr) {
+                if (oLstnr) {
+                    oListener.listeners.push(oLstnr);
+                    if (oLstnr.onAttachToLog) {
+                        oLstnr.onAttachToLog(oLog);
+                    }
+                }
+            },
+            detach: function (oLog, oLstnr) {
+                for (var i = 0; i < oListener.listeners.length; i++) {
+                    if (oListener.listeners[i] === oLstnr) {
+                        if (oLstnr.onDetachFromLog) {
+                            oLstnr.onDetachFromLog(oLog);
+                        }
+                        oListener.listeners.splice(i, 1);
+                        return;
+                    }
+                }
+            }
+        };
+    }
+    return oListener;
+}
+Log.fatal = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+    log(Log.Level.FATAL, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.error = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+    log(Log.Level.ERROR, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.warning = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+    log(Log.Level.WARNING, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.info = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+    log(Log.Level.INFO, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.debug = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+    log(Log.Level.DEBUG, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.trace = function (sMessage, sDetails, sComponent, fnSupportInfo) {
+    log(Log.Level.TRACE, sMessage, sDetails, sComponent, fnSupportInfo);
+};
+Log.setLevel = function (iLogLevel, sComponent, _bDefault) {
+    sComponent = sComponent || sDefaultComponent || '';
+    if (!_bDefault || mMaxLevel[sComponent] == null) {
+        mMaxLevel[sComponent] = iLogLevel;
+        var sLogLevel;
+        Object.keys(Log.Level).forEach(function (sLevel) {
+            if (Log.Level[sLevel] === iLogLevel) {
+                sLogLevel = sLevel;
+            }
+        });
+        log(Log.Level.INFO, 'Changing log level ' + (sComponent ? 'for \'' + sComponent + '\' ' : '') + 'to ' + sLogLevel, '', 'sap.base.log');
+    }
+};
+Log.getLevel = function (sComponent) {
+    return level(sComponent || sDefaultComponent);
+};
+Log.isLoggable = function (iLevel, sComponent) {
+    return (iLevel == null ? Log.Level.DEBUG : iLevel) <= level(sComponent || sDefaultComponent);
+};
+Log.logSupportInfo = function (bEnabled) {
+    bLogSupportInfo = bEnabled;
+};
+function log(iLevel, sMessage, sDetails, sComponent, fnSupportInfo) {
+    if (!fnSupportInfo && !sComponent && typeof sDetails === 'function') {
+        fnSupportInfo = sDetails;
+        sDetails = '';
+    }
+    if (!fnSupportInfo && typeof sComponent === 'function') {
+        fnSupportInfo = sComponent;
+        sComponent = '';
+    }
+    sComponent = sComponent || sDefaultComponent;
+    if (iLevel <= level(sComponent)) {
+        var fNow = now(), oNow = new Date(fNow), iMicroSeconds = Math.floor((fNow - Math.floor(fNow)) * 1000), oLogEntry = {
+                time: pad0(oNow.getHours(), 2) + ':' + pad0(oNow.getMinutes(), 2) + ':' + pad0(oNow.getSeconds(), 2) + '.' + pad0(oNow.getMilliseconds(), 3) + pad0(iMicroSeconds, 3),
+                date: pad0(oNow.getFullYear(), 4) + '-' + pad0(oNow.getMonth() + 1, 2) + '-' + pad0(oNow.getDate(), 2),
+                timestamp: fNow,
+                level: iLevel,
+                message: String(sMessage || ''),
+                details: String(sDetails || ''),
+                component: String(sComponent || '')
+            };
+        if (bLogSupportInfo && typeof fnSupportInfo === 'function') {
+            oLogEntry.supportInfo = fnSupportInfo();
+        }
+        if (iLogEntriesLimit) {
+            if (aLog.length >= iLogEntriesLimit) {
+                discardLogEntries();
+            }
+            aLog.push(oLogEntry);
+        }
+        if (oListener) {
+            oListener.onLogEntry(oLogEntry);
+        }
+        if (console) {
+            var isDetailsError = sDetails instanceof Error, logText = oLogEntry.date + ' ' + oLogEntry.time + ' ' + oLogEntry.message + ' - ' + oLogEntry.details + ' ' + oLogEntry.component;
+            switch (iLevel) {
+            case Log.Level.FATAL:
+            case Log.Level.ERROR:
+                isDetailsError ? console.error(logText, '\n', sDetails) : console.error(logText);
+                break;
+            case Log.Level.WARNING:
+                isDetailsError ? console.warn(logText, '\n', sDetails) : console.warn(logText);
+                break;
+            case Log.Level.INFO:
+                if (console.info) {
+                    isDetailsError ? console.info(logText, '\n', sDetails) : console.info(logText);
+                } else {
+                    isDetailsError ? console.log(logText, '\n', sDetails) : console.log(logText);
+                }
+                break;
+            case Log.Level.DEBUG:
+                isDetailsError ? console.debug(logText, '\n', sDetails) : console.debug(logText);
+                break;
+            case Log.Level.TRACE:
+                isDetailsError ? console.trace(logText, '\n', sDetails) : console.trace(logText);
+                break;
+            }
+            if (console.info && oLogEntry.supportInfo) {
+                console.info(oLogEntry.supportInfo);
+            }
+        }
+        return oLogEntry;
+    }
+}
+Log.getLogEntries = function () {
+    return aLog.slice();
+};
+Log.getLogEntriesLimit = function () {
+    return iLogEntriesLimit;
+};
+Log.setLogEntriesLimit = function (iLimit) {
+    if (iLimit < 0) {
+        throw new Error('The log entries limit needs to be greater than or equal to 0!');
+    }
+    iLogEntriesLimit = iLimit;
+    if (aLog.length >= iLogEntriesLimit) {
+        discardLogEntries();
+    }
+};
+Log.addLogListener = function (oListener) {
+    getLogEntryListenerInstance().attach(this, oListener);
+};
+Log.removeLogListener = function (oListener) {
+    getLogEntryListenerInstance().detach(this, oListener);
+};
+function Logger(sComponent) {
+    this.fatal = function (msg, detail, comp, support) {
+        Log.fatal(msg, detail, comp || sComponent, support);
+        return this;
+    };
+    this.error = function (msg, detail, comp, support) {
+        Log.error(msg, detail, comp || sComponent, support);
+        return this;
+    };
+    this.warning = function (msg, detail, comp, support) {
+        Log.warning(msg, detail, comp || sComponent, support);
+        return this;
+    };
+    this.info = function (msg, detail, comp, support) {
+        Log.info(msg, detail, comp || sComponent, support);
+        return this;
+    };
+    this.debug = function (msg, detail, comp, support) {
+        Log.debug(msg, detail, comp || sComponent, support);
+        return this;
+    };
+    this.trace = function (msg, detail, comp, support) {
+        Log.trace(msg, detail, comp || sComponent, support);
+        return this;
+    };
+    this.setLevel = function (level, comp) {
+        Log.setLevel(level, comp || sComponent);
+        return this;
+    };
+    this.getLevel = function (comp) {
+        return Log.getLevel(comp || sComponent);
+    };
+    this.isLoggable = function (level, comp) {
+        return Log.isLoggable(level, comp || sComponent);
+    };
+}
+Log.getLogger = function (sComponent, iDefaultLogLevel) {
+    if (!isNaN(iDefaultLogLevel) && mMaxLevel[sComponent] == null) {
+        mMaxLevel[sComponent] = iDefaultLogLevel;
+    }
+    return new Logger(sComponent);
+};
+export default Log;

package/dist/sap/base/assert.js

@@ -0,0 +1,8 @@
+import Log from './Log.js';
+var fnAssert = function (bResult, vMessage) {
+    if (!bResult) {
+        var sMessage = typeof vMessage === 'function' ? vMessage() : vMessage;
+        console.assert(bResult, sMessage);
+    }
+};
+export default fnAssert;