@ui5/webcomponents-localization 0.0.0-d9933bd82 → 0.0.0-db622d8a8

package/dist/sap/ui/core/date/Buddhist.js

@@ -117,11 +117,5 @@ Buddhist.prototype.setUTCFullYear = function (iYear, iMonth, iDay) {
     }
     return this._setUTCBuddhist(oBuddhist);
 };
-Buddhist.prototype.getWeek = function () {
-    return UniversalDate.getWeekByDate(this.sCalendarType, this.oDate.getFullYear(), this.getMonth(), this.getDate());
-};
-Buddhist.prototype.getUTCWeek = function () {
-    return UniversalDate.getWeekByDate(this.sCalendarType, this.oDate.getUTCFullYear(), this.getUTCMonth(), this.getUTCDate());
-};
 _Calendars.set(CalendarType.Buddhist, Buddhist);
 export default Buddhist;

package/dist/sap/ui/core/date/CalendarUtils.js

@@ -0,0 +1,36 @@
+import CalendarWeekNumbering from './CalendarWeekNumbering.js';
+import Configuration from '../Configuration.js';
+import LocaleData from '../LocaleData.js';
+var mWeekNumberingConfiguration = {
+    ISO_8601: {
+        firstDayOfWeek: 1,
+        minimalDaysInFirstWeek: 4
+    },
+    MiddleEastern: {
+        firstDayOfWeek: 6,
+        minimalDaysInFirstWeek: 1
+    },
+    WesternTraditional: {
+        firstDayOfWeek: 0,
+        minimalDaysInFirstWeek: 1
+    }
+};
+var CalendarUtils = {
+    getWeekConfigurationValues: function (sCalendarWeekNumbering, oLocale) {
+        var oLocaleData;
+        if (mWeekNumberingConfiguration.hasOwnProperty(sCalendarWeekNumbering)) {
+            return mWeekNumberingConfiguration[sCalendarWeekNumbering];
+        }
+        sCalendarWeekNumbering = sCalendarWeekNumbering || CalendarWeekNumbering.Default;
+        if (sCalendarWeekNumbering === CalendarWeekNumbering.Default) {
+            oLocale = oLocale || Configuration.getFormatSettings().getFormatLocale();
+            oLocaleData = LocaleData.getInstance(oLocale);
+            return {
+                firstDayOfWeek: oLocaleData.getFirstDayOfWeek(),
+                minimalDaysInFirstWeek: oLocaleData.getMinimalDaysInFirstWeek()
+            };
+        }
+        return undefined;
+    }
+};
+export default CalendarUtils;

package/dist/sap/ui/core/date/CalendarWeekNumbering.js

@@ -0,0 +1,7 @@
+var CalendarWeekNumbering = {
+  Default: "Default",
+  ISO_8601: "ISO_8601",
+  MiddleEastern: "MiddleEastern",
+  WesternTraditional: "WesternTraditional"
+};
+export default CalendarWeekNumbering;

package/dist/sap/ui/core/date/Islamic.js

@@ -1,8 +1,8 @@
-import Core from '../Core.js';
 import UniversalDate from './UniversalDate.js';
 import CalendarType from '../CalendarType.js';
 import Log from '../../../base/Log.js';
 import _Calendars from './_Calendars.js';
+import Configuration from '../Configuration.js';
 var Islamic = UniversalDate.extend('sap.ui.core.date.Islamic', {
     constructor: function () {
         var aArgs = arguments;
@@ -102,9 +102,9 @@ function toGregorianArguments(aArgs) {
 function initCustomizationMap() {
     var sDateFormat, oCustomizationJSON;
     oCustomizationMap = {};
-    sDateFormat = Core.getConfiguration().getFormatSettings().getLegacyDateFormat();
+    sDateFormat = Configuration.getFormatSettings().getLegacyDateFormat();
     sDateFormat = _isSupportedIslamicCalendarType(sDateFormat) ? sDateFormat : 'A';
-    oCustomizationJSON = Core.getConfiguration().getFormatSettings().getLegacyDateCalendarCustomizing();
+    oCustomizationJSON = Configuration.getFormatSettings().getLegacyDateCalendarCustomizing();
     oCustomizationJSON = oCustomizationJSON || [];
     if (!oCustomizationJSON.length) {
         Log.warning('No calendar customizations.');

package/dist/sap/ui/core/date/Japanese.js

@@ -152,11 +152,11 @@ Japanese.prototype.setUTCEra = function (iEra, iYear, iMonth, iDay) {
     }
     return this._setUTCJapanese(oJapanese);
 };
-Japanese.prototype.getWeek = function () {
-    return UniversalDate.getWeekByDate(this.sCalendarType, this.oDate.getFullYear(), this.getMonth(), this.getDate());
+Japanese.prototype.getWeek = function (oLocale, vCalendarWeekNumbering) {
+    return UniversalDate.getWeekByDate(this.sCalendarType, this.oDate.getFullYear(), this.getMonth(), this.getDate(), oLocale, vCalendarWeekNumbering);
 };
-Japanese.prototype.getUTCWeek = function () {
-    return UniversalDate.getWeekByDate(this.sCalendarType, this.oDate.getUTCFullYear(), this.getUTCMonth(), this.getUTCDate());
+Japanese.prototype.getUTCWeek = function (oLocale, vCalendarWeekNumbering) {
+    return UniversalDate.getWeekByDate(this.sCalendarType, this.oDate.getUTCFullYear(), this.getUTCMonth(), this.getUTCDate(), oLocale, vCalendarWeekNumbering);
 };
 _Calendars.set(CalendarType.Japanese, Japanese);
 export default Japanese;

package/dist/sap/ui/core/date/UI5Date.js

@@ -0,0 +1,305 @@
+import Configuration from '../Configuration.js';
+import TimezoneUtil from '../format/TimezoneUtil.js';
+var aAllParts = [
+        'year',
+        'month',
+        'day',
+        'hour',
+        'minute',
+        'second',
+        'fractionalSecond'
+    ], rIsUTCString = /Z|GMT|:.*[\+|\-]|^([\+|\-]\d{2})?\d{4}(-\d{2}){0,2}$/, aWeekday = [
+        'Sun',
+        'Mon',
+        'Tue',
+        'Wed',
+        'Thu',
+        'Fri',
+        'Sat'
+    ], aMonths = [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec'
+    ], mWeekdayToDay = {
+        Sun: 0,
+        Mon: 1,
+        Tue: 2,
+        Wed: 3,
+        Thu: 4,
+        Fri: 5,
+        Sat: 6
+    };
+function addLeadingZeros(iValue, iLength) {
+    return (iValue < 0 ? '-' : '') + Math.abs(iValue).toString().padStart(iLength, '0');
+}
+function UI5Date(vDateParts, sTimezoneID) {
+    var oDateInstance = UI5Date._createDateInstance(vDateParts);
+    Object.defineProperties(this, {
+        sTimezoneID: { value: sTimezoneID },
+        oDate: {
+            value: oDateInstance,
+            writable: true
+        },
+        oDateParts: {
+            value: undefined,
+            writable: true
+        }
+    });
+    if (isNaN(oDateInstance)) {
+        return;
+    }
+    if (vDateParts.length > 1 || vDateParts.length === 1 && typeof vDateParts[0] === 'string' && !rIsUTCString.test(vDateParts[0])) {
+        this._setParts(aAllParts, [
+            oDateInstance.getFullYear(),
+            oDateInstance.getMonth(),
+            oDateInstance.getDate(),
+            oDateInstance.getHours(),
+            oDateInstance.getMinutes(),
+            oDateInstance.getSeconds(),
+            oDateInstance.getMilliseconds()
+        ]);
+    }
+}
+UI5Date.prototype = Object.create(Date.prototype, { constructor: { value: Date } });
+UI5Date.prototype[Symbol.toStringTag] = 'Date';
+UI5Date.prototype._getPart = function (sPart) {
+    var iResult;
+    if (isNaN(this.oDate)) {
+        return NaN;
+    }
+    this.oDateParts = this.oDateParts || TimezoneUtil._getParts(this.oDate, this.sTimezoneID);
+    if (sPart === 'weekday') {
+        return mWeekdayToDay[this.oDateParts.weekday];
+    }
+    iResult = parseInt(this.oDateParts[sPart]);
+    if (sPart === 'month') {
+        iResult -= 1;
+    } else if (sPart === 'year') {
+        if (this.oDateParts.era === 'B') {
+            iResult = 1 - iResult;
+        }
+    }
+    return iResult;
+};
+UI5Date.prototype._setParts = function (aParts, aValues) {
+    var i, oCurrentDateParts, oNewDateAsUTCTimestamp, iNewTimestamp, sPart, vValue, oDateParts = {}, iMaxLength = Math.min(aParts.length, aValues.length);
+    if (iMaxLength === 0) {
+        return this.setTime(NaN);
+    }
+    for (i = 0; i < iMaxLength; i += 1) {
+        vValue = parseInt(+aValues[i]);
+        sPart = aParts[i];
+        if (isNaN(vValue)) {
+            return this.setTime(NaN);
+        }
+        if (sPart === 'month') {
+            vValue += 1;
+        } else if (sPart === 'year') {
+            if (vValue <= 0) {
+                vValue = 1 - vValue;
+                oDateParts.era = 'B';
+            } else {
+                oDateParts.era = 'A';
+            }
+        }
+        oDateParts[sPart] = vValue.toString();
+    }
+    if (this.oDateParts) {
+        oCurrentDateParts = this.oDateParts;
+    } else if (isNaN(this.oDate)) {
+        oCurrentDateParts = {
+            day: '1',
+            fractionalSecond: '0',
+            hour: '0',
+            minute: '0',
+            month: '1',
+            second: '0'
+        };
+    } else {
+        oCurrentDateParts = TimezoneUtil._getParts(this.oDate, this.sTimezoneID);
+    }
+    oDateParts = Object.assign({}, oCurrentDateParts, oDateParts);
+    oNewDateAsUTCTimestamp = TimezoneUtil._getDateFromParts(oDateParts);
+    if (isNaN(oNewDateAsUTCTimestamp)) {
+        return this.setTime(NaN);
+    }
+    iNewTimestamp = oNewDateAsUTCTimestamp.getTime() + TimezoneUtil.calculateOffset(oNewDateAsUTCTimestamp, this.sTimezoneID) * 1000;
+    return this.setTime(iNewTimestamp);
+};
+UI5Date.prototype.clone = function () {
+    return UI5Date.getInstance(this);
+};
+UI5Date.prototype.getDate = function () {
+    return this._getPart('day');
+};
+UI5Date.prototype.getDay = function () {
+    return this._getPart('weekday');
+};
+UI5Date.prototype.getFullYear = function () {
+    return this._getPart('year');
+};
+UI5Date.prototype.getHours = function () {
+    return this._getPart('hour');
+};
+UI5Date.prototype.getMilliseconds = function () {
+    return this._getPart('fractionalSecond');
+};
+UI5Date.prototype.getMinutes = function () {
+    return this._getPart('minute');
+};
+UI5Date.prototype.getMonth = function () {
+    return this._getPart('month');
+};
+UI5Date.prototype.getSeconds = function () {
+    return this._getPart('second');
+};
+UI5Date.prototype.getTimezoneOffset = function () {
+    return TimezoneUtil.calculateOffset(this.oDate, this.sTimezoneID) / 60;
+};
+UI5Date.prototype.getYear = function () {
+    return this._getPart('year') - 1900;
+};
+UI5Date.prototype.setDate = function (iDay) {
+    return this._setParts(['day'], arguments);
+};
+UI5Date.prototype.setFullYear = function (iYear, iMonth, iDay) {
+    return this._setParts([
+        'year',
+        'month',
+        'day'
+    ], arguments);
+};
+UI5Date.prototype.setHours = function (iHours, iMinutes, iSeconds, iMilliseconds) {
+    return this._setParts([
+        'hour',
+        'minute',
+        'second',
+        'fractionalSecond'
+    ], arguments);
+};
+UI5Date.prototype.setMilliseconds = function (iMilliseconds) {
+    return this._setParts(['fractionalSecond'], arguments);
+};
+UI5Date.prototype.setMinutes = function (iMinutes, iSeconds, iMilliseconds) {
+    return this._setParts([
+        'minute',
+        'second',
+        'fractionalSecond'
+    ], arguments);
+};
+UI5Date.prototype.setMonth = function (iMonth, iDay) {
+    return this._setParts([
+        'month',
+        'day'
+    ], arguments);
+};
+UI5Date.prototype.setSeconds = function (iSeconds, iMilliseconds) {
+    return this._setParts([
+        'second',
+        'fractionalSecond'
+    ], arguments);
+};
+UI5Date.prototype.setTime = function (iTime) {
+    this.oDateParts = undefined;
+    return this.oDate.setTime(iTime);
+};
+UI5Date.prototype.setYear = function (iYear) {
+    return this._setParts(['year'], [parseInt(iYear) + 1900]);
+};
+UI5Date.prototype.toDateString = function () {
+    if (isNaN(this.oDate)) {
+        return this.oDate.toDateString();
+    }
+    return aWeekday[this.getDay()] + ' ' + aMonths[this.getMonth()] + ' ' + addLeadingZeros(this.getDate(), 2) + ' ' + addLeadingZeros(this.getFullYear(), 4);
+};
+UI5Date.prototype.toString = function () {
+    if (isNaN(this.oDate)) {
+        return this.oDate.toString();
+    }
+    return this.toDateString() + ' ' + this.toTimeString();
+};
+UI5Date.prototype.toTimeString = function () {
+    var iHours, iMinutes, sSign, iTimeZoneOffset;
+    if (isNaN(this.oDate)) {
+        return this.oDate.toTimeString();
+    }
+    iTimeZoneOffset = this.getTimezoneOffset();
+    sSign = iTimeZoneOffset > 0 ? '-' : '+';
+    iHours = Math.floor(Math.abs(iTimeZoneOffset) / 60);
+    iMinutes = Math.abs(iTimeZoneOffset) % 60;
+    return addLeadingZeros(this.getHours(), 2) + ':' + addLeadingZeros(this.getMinutes(), 2) + ':' + addLeadingZeros(this.getSeconds(), 2) + ' GMT' + sSign + addLeadingZeros(iHours, 2) + addLeadingZeros(iMinutes, 2);
+};
+[
+    'getTime',
+    'getUTCDate',
+    'getUTCDay',
+    'getUTCFullYear',
+    'getUTCHours',
+    'getUTCMilliseconds',
+    'getUTCMinutes',
+    'getUTCMonth',
+    'getUTCSeconds',
+    'toGMTString',
+    'toISOString',
+    'toJSON',
+    'toUTCString',
+    'valueOf'
+].forEach(function (sMethod) {
+    UI5Date.prototype[sMethod] = function () {
+        return this.oDate[sMethod].apply(this.oDate, arguments);
+    };
+});
+[
+    'toLocaleDateString',
+    'toLocaleString',
+    'toLocaleTimeString'
+].forEach(function (sMethod) {
+    UI5Date.prototype[sMethod] = function (sLocale, oOptions) {
+        return this.oDate[sMethod](sLocale || Configuration.getLanguageTag(), Object.assign({ timeZone: this.sTimezoneID }, oOptions));
+    };
+});
+[
+    'setUTCDate',
+    'setUTCFullYear',
+    'setUTCHours',
+    'setUTCMilliseconds',
+    'setUTCMinutes',
+    'setUTCMonth',
+    'setUTCSeconds'
+].forEach(function (sMethod) {
+    UI5Date.prototype[sMethod] = function () {
+        this.oDateParts = undefined;
+        return this.oDate[sMethod].apply(this.oDate, arguments);
+    };
+});
+UI5Date._createDateInstance = function (vParts) {
+    if (vParts[0] instanceof Date) {
+        vParts[0] = vParts[0].valueOf();
+    }
+    return new (Function.prototype.bind.apply(Date, [].concat.apply([null], vParts)))();
+};
+UI5Date.getInstance = function () {
+    var sTimezone = Configuration.getTimezone();
+    if (sTimezone !== TimezoneUtil.getLocalTimezone()) {
+        return new UI5Date(arguments, sTimezone);
+    }
+    return UI5Date._createDateInstance(arguments);
+};
+UI5Date.checkDate = function (oDate) {
+    if (isNaN(oDate.getTime())) {
+        throw new Error('The given Date is not valid');
+    }
+    if (!(oDate instanceof UI5Date) && Configuration.getTimezone() !== TimezoneUtil.getLocalTimezone()) {
+        throw new Error('Configured time zone requires the parameter \'oDate\' to be an instance of' + ' sap.ui.core.date.UI5Date');
+    }
+};
+export default UI5Date;

package/dist/sap/ui/core/date/UniversalDate.js

@@ -1,7 +1,10 @@
-import Core from '../Core.js';
 import BaseObject from '../../base/Object.js';
+import Configuration from '../Configuration.js';
 import LocaleData from '../LocaleData.js';
 import _Calendars from './_Calendars.js';
+import CalendarUtils from './CalendarUtils.js';
+import CalendarWeekNumbering from './CalendarWeekNumbering.js';
+import UI5Date from './UI5Date.js';
 var UniversalDate = BaseObject.extend('sap.ui.core.date.UniversalDate', {
     constructor: function () {
         var clDate = UniversalDate.getClass();
@@ -16,11 +19,14 @@ UniversalDate.now = function () {
     return Date.now();
 };
 UniversalDate.prototype.createDate = function (clDate, aArgs) {
+    if (clDate === Date) {
+        return UI5Date.getInstance.apply(null, aArgs);
+    }
     switch (aArgs.length) {
     case 0:
         return new clDate();
     case 1:
-        return new clDate(aArgs[0]);
+        return new clDate(aArgs[0] instanceof Date ? aArgs[0].getTime() : aArgs[0]);
     case 2:
         return new clDate(aArgs[0], aArgs[1]);
     case 3:
@@ -40,18 +46,21 @@ UniversalDate.getInstance = function (oDate, sCalendarType) {
     if (oDate instanceof UniversalDate) {
         oDate = oDate.getJSDate();
     }
+    if (oDate && isNaN(oDate.getTime())) {
+        throw new Error('The given date object is invalid');
+    }
     if (!sCalendarType) {
-        sCalendarType = Core.getConfiguration().getCalendarType();
+        sCalendarType = Configuration.getCalendarType();
     }
     clDate = UniversalDate.getClass(sCalendarType);
     oInstance = Object.create(clDate.prototype);
-    oInstance.oDate = oDate;
+    oInstance.oDate = oDate ? UI5Date.getInstance(oDate) : UI5Date.getInstance();
     oInstance.sCalendarType = sCalendarType;
     return oInstance;
 };
 UniversalDate.getClass = function (sCalendarType) {
     if (!sCalendarType) {
-        sCalendarType = Core.getConfiguration().getCalendarType();
+        sCalendarType = Configuration.getCalendarType();
     }
     return _Calendars.get(sCalendarType);
 };
@@ -114,18 +123,22 @@ UniversalDate.prototype.getUTCEra = function () {
 };
 UniversalDate.prototype.setUTCEra = function (iEra) {
 };
-UniversalDate.prototype.getWeek = function () {
-    return UniversalDate.getWeekByDate(this.sCalendarType, this.getFullYear(), this.getMonth(), this.getDate());
+UniversalDate.prototype.getWeek = function (oLocale, vCalendarWeekNumbering) {
+    checkWeekConfig(vCalendarWeekNumbering);
+    return UniversalDate.getWeekByDate(this.sCalendarType, this.getFullYear(), this.getMonth(), this.getDate(), oLocale, vCalendarWeekNumbering);
 };
-UniversalDate.prototype.setWeek = function (oWeek) {
-    var oDate = UniversalDate.getFirstDateOfWeek(this.sCalendarType, oWeek.year || this.getFullYear(), oWeek.week);
+UniversalDate.prototype.setWeek = function (oWeek, oLocale, vCalendarWeekNumbering) {
+    checkWeekConfig(vCalendarWeekNumbering);
+    var oDate = UniversalDate.getFirstDateOfWeek(this.sCalendarType, oWeek.year || this.getFullYear(), oWeek.week, oLocale, vCalendarWeekNumbering);
     this.setFullYear(oDate.year, oDate.month, oDate.day);
 };
-UniversalDate.prototype.getUTCWeek = function () {
-    return UniversalDate.getWeekByDate(this.sCalendarType, this.getUTCFullYear(), this.getUTCMonth(), this.getUTCDate());
+UniversalDate.prototype.getUTCWeek = function (oLocale, vCalendarWeekNumbering) {
+    checkWeekConfig(vCalendarWeekNumbering);
+    return UniversalDate.getWeekByDate(this.sCalendarType, this.getUTCFullYear(), this.getUTCMonth(), this.getUTCDate(), oLocale, vCalendarWeekNumbering);
 };
-UniversalDate.prototype.setUTCWeek = function (oWeek) {
-    var oDate = UniversalDate.getFirstDateOfWeek(this.sCalendarType, oWeek.year || this.getFullYear(), oWeek.week);
+UniversalDate.prototype.setUTCWeek = function (oWeek, oLocale, vCalendarWeekNumbering) {
+    checkWeekConfig(vCalendarWeekNumbering);
+    var oDate = UniversalDate.getFirstDateOfWeek(this.sCalendarType, oWeek.year || this.getFullYear(), oWeek.week, oLocale, vCalendarWeekNumbering);
     this.setUTCFullYear(oDate.year, oDate.month, oDate.day);
 };
 UniversalDate.prototype.getQuarter = function () {
@@ -159,15 +172,21 @@ UniversalDate.prototype.getTimezoneLong = function () {
     }
 };
 var iMillisecondsInWeek = 7 * 24 * 60 * 60 * 1000;
-UniversalDate.getWeekByDate = function (sCalendarType, iYear, iMonth, iDay) {
-    var oLocale = Core.getConfiguration().getFormatSettings().getFormatLocale(), clDate = this.getClass(sCalendarType), oFirstDay = getFirstDayOfFirstWeek(clDate, iYear), oDate = new clDate(clDate.UTC(iYear, iMonth, iDay)), iWeek, iLastYear, iNextYear, oLastFirstDay, oNextFirstDay;
-    if (oLocale.getRegion() === 'US') {
+UniversalDate.getWeekByDate = function (sCalendarType, iYear, iMonth, iDay, oLocale, vCalendarWeekNumbering) {
+    checkWeekConfig(vCalendarWeekNumbering);
+    oLocale = oLocale || Configuration.getFormatSettings().getFormatLocale();
+    var clDate = this.getClass(sCalendarType);
+    var oFirstDay = getFirstDayOfFirstWeek(clDate, iYear, oLocale, vCalendarWeekNumbering);
+    var oDate = new clDate(clDate.UTC(iYear, iMonth, iDay));
+    var iWeek, iLastYear, iNextYear, oLastFirstDay, oNextFirstDay;
+    var bSplitWeek = isSplitWeek(vCalendarWeekNumbering, oLocale);
+    if (bSplitWeek) {
         iWeek = calculateWeeks(oFirstDay, oDate);
     } else {
         iLastYear = iYear - 1;
         iNextYear = iYear + 1;
-        oLastFirstDay = getFirstDayOfFirstWeek(clDate, iLastYear);
-        oNextFirstDay = getFirstDayOfFirstWeek(clDate, iNextYear);
+        oLastFirstDay = getFirstDayOfFirstWeek(clDate, iLastYear, oLocale, vCalendarWeekNumbering);
+        oNextFirstDay = getFirstDayOfFirstWeek(clDate, iNextYear, oLocale, vCalendarWeekNumbering);
         if (oDate >= oNextFirstDay) {
             iYear = iNextYear;
             iWeek = 0;
@@ -183,9 +202,14 @@ UniversalDate.getWeekByDate = function (sCalendarType, iYear, iMonth, iDay) {
         week: iWeek
     };
 };
-UniversalDate.getFirstDateOfWeek = function (sCalendarType, iYear, iWeek) {
-    var oLocale = Core.getConfiguration().getFormatSettings().getFormatLocale(), clDate = this.getClass(sCalendarType), oFirstDay = getFirstDayOfFirstWeek(clDate, iYear), oDate = new clDate(oFirstDay.valueOf() + iWeek * iMillisecondsInWeek);
-    if (oLocale.getRegion() === 'US' && iWeek === 0 && oFirstDay.getUTCFullYear() < iYear) {
+UniversalDate.getFirstDateOfWeek = function (sCalendarType, iYear, iWeek, oLocale, vCalendarWeekNumbering) {
+    checkWeekConfig(vCalendarWeekNumbering);
+    oLocale = oLocale || Configuration.getFormatSettings().getFormatLocale();
+    var clDate = this.getClass(sCalendarType);
+    var oFirstDay = getFirstDayOfFirstWeek(clDate, iYear, oLocale, vCalendarWeekNumbering);
+    var oDate = new clDate(oFirstDay.valueOf() + iWeek * iMillisecondsInWeek);
+    var bSplitWeek = isSplitWeek(vCalendarWeekNumbering, oLocale);
+    if (bSplitWeek && iWeek === 0 && oFirstDay.getUTCFullYear() < iYear) {
         return {
             year: iYear,
             month: 0,
@@ -198,8 +222,44 @@ UniversalDate.getFirstDateOfWeek = function (sCalendarType, iYear, iWeek) {
         day: oDate.getUTCDate()
     };
 };
-function getFirstDayOfFirstWeek(clDate, iYear) {
-    var oLocale = Core.getConfiguration().getFormatSettings().getFormatLocale(), oLocaleData = LocaleData.getInstance(oLocale), iMinDays = oLocaleData.getMinimalDaysInFirstWeek(), iFirstDayOfWeek = oLocaleData.getFirstDayOfWeek(), oFirstDay = new clDate(clDate.UTC(iYear, 0, 1)), iDayCount = 7;
+function isSplitWeek(vCalendarWeekNumbering, oLocale) {
+    oLocale = oLocale || Configuration.getFormatSettings().getFormatLocale();
+    var oLocaleData = LocaleData.getInstance(oLocale);
+    return (!isCalendarWeekConfigurationDefined(vCalendarWeekNumbering) || vCalendarWeekNumbering === CalendarWeekNumbering.Default) && oLocaleData.firstDayStartsFirstWeek();
+}
+function checkWeekConfig(vCalendarWeekNumbering) {
+    if (typeof vCalendarWeekNumbering === 'object') {
+        if (!isCalendarWeekConfigurationDefined(vCalendarWeekNumbering)) {
+            throw new TypeError('Week config requires firstDayOfWeek and minimalDaysInFirstWeek to be set');
+        }
+    } else if (vCalendarWeekNumbering && !Object.values(CalendarWeekNumbering).includes(vCalendarWeekNumbering)) {
+        throw new TypeError('Illegal format option calendarWeekNumbering: \'' + vCalendarWeekNumbering + '\'');
+    }
+}
+function isCalendarWeekConfigurationDefined(vCalendarWeekNumbering) {
+    if (typeof vCalendarWeekNumbering === 'object') {
+        return typeof vCalendarWeekNumbering.firstDayOfWeek === 'number' && typeof vCalendarWeekNumbering.minimalDaysInFirstWeek === 'number';
+    } else if (vCalendarWeekNumbering) {
+        return true;
+    }
+    return false;
+}
+function resolveCalendarWeekConfiguration(vCalendarWeekNumbering, oLocale) {
+    if (typeof vCalendarWeekNumbering === 'object' && typeof vCalendarWeekNumbering.firstDayOfWeek === 'number' && typeof vCalendarWeekNumbering.minimalDaysInFirstWeek === 'number') {
+        return vCalendarWeekNumbering;
+    }
+    return CalendarUtils.getWeekConfigurationValues(vCalendarWeekNumbering, oLocale);
+}
+function getFirstDayOfFirstWeek(clDate, iYear, oLocale, vCalendarWeekNumbering) {
+    oLocale = oLocale || Configuration.getFormatSettings().getFormatLocale();
+    var oWeekConfig = resolveCalendarWeekConfiguration(vCalendarWeekNumbering, oLocale);
+    var iMinDays = oWeekConfig.minimalDaysInFirstWeek;
+    var iFirstDayOfWeek = oWeekConfig.firstDayOfWeek;
+    var oFirstDay = new clDate(clDate.UTC(iYear, 0, 1));
+    var iDayCount = 7;
+    if (isNaN(oFirstDay.getTime())) {
+        throw new Error('Could not determine the first day of the week, because the date ' + 'object is invalid');
+    }
     while (oFirstDay.getUTCDay() !== iFirstDayOfWeek) {
         oFirstDay.setUTCDate(oFirstDay.getUTCDate() - 1);
         iDayCount--;
@@ -229,7 +289,7 @@ UniversalDate.getEraByDate = function (sCalendarType, iYear, iMonth, iDay) {
     }
 };
 UniversalDate.getCurrentEra = function (sCalendarType) {
-    var oNow = new Date();
+    var oNow = UI5Date.getInstance();
     return this.getEraByDate(sCalendarType, oNow.getFullYear(), oNow.getMonth(), oNow.getDate());
 };
 UniversalDate.getEraStartDate = function (sCalendarType, iEra) {
@@ -239,7 +299,7 @@ UniversalDate.getEraStartDate = function (sCalendarType, iEra) {
     }
 };
 function getEras(sCalendarType) {
-    var oLocale = Core.getConfiguration().getFormatSettings().getFormatLocale(), oLocaleData = LocaleData.getInstance(oLocale), aEras = mEras[sCalendarType];
+    var oLocale = Configuration.getFormatSettings().getFormatLocale(), oLocaleData = LocaleData.getInstance(oLocale), aEras = mEras[sCalendarType];
     if (!aEras) {
         var aEras = oLocaleData.getEraDates(sCalendarType);
         if (!aEras[0]) {