@ui5/webcomponents-localization 0.0.0-998083e44 → 0.0.0-99b763015

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/UniversalDate.js

@@ -1,7 +1,10 @@
-import Core from '../Core.js';
 import BaseObject from '../../base/Object.js';
+import Configuration from '../Configuration.js';
+import Locale from '../Locale.js';
 import LocaleData from '../LocaleData.js';
 import _Calendars from './_Calendars.js';
+import CalendarUtils from './CalendarUtils.js';
+import CalendarWeekNumbering from './CalendarWeekNumbering.js';
 var UniversalDate = BaseObject.extend('sap.ui.core.date.UniversalDate', {
     constructor: function () {
         var clDate = UniversalDate.getClass();
@@ -46,7 +49,7 @@ UniversalDate.getInstance = function (oDate, sCalendarType) {
         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);
@@ -56,7 +59,7 @@ UniversalDate.getInstance = function (oDate, sCalendarType) {
 };
 UniversalDate.getClass = function (sCalendarType) {
     if (!sCalendarType) {
-        sCalendarType = Core.getConfiguration().getCalendarType();
+        sCalendarType = Configuration.getCalendarType();
     }
     return _Calendars.get(sCalendarType);
 };
@@ -119,18 +122,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 () {
@@ -164,15 +171,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(), oLocaleData = LocaleData.getInstance(oLocale), clDate = this.getClass(sCalendarType), oFirstDay = getFirstDayOfFirstWeek(clDate, iYear), oDate = new clDate(clDate.UTC(iYear, iMonth, iDay)), iWeek, iLastYear, iNextYear, oLastFirstDay, oNextFirstDay;
-    if (oLocaleData.firstDayStartsFirstWeek()) {
+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;
@@ -188,9 +201,14 @@ UniversalDate.getWeekByDate = function (sCalendarType, iYear, iMonth, iDay) {
         week: iWeek
     };
 };
-UniversalDate.getFirstDateOfWeek = function (sCalendarType, iYear, iWeek) {
-    var oLocale = Core.getConfiguration().getFormatSettings().getFormatLocale(), oLocaleData = LocaleData.getInstance(oLocale), clDate = this.getClass(sCalendarType), oFirstDay = getFirstDayOfFirstWeek(clDate, iYear), oDate = new clDate(oFirstDay.valueOf() + iWeek * iMillisecondsInWeek), bIsRegionUS = oLocaleData.firstDayStartsFirstWeek();
-    if (bIsRegionUS && 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,
@@ -203,8 +221,41 @@ 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');
     }
@@ -247,7 +298,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]) {

package/dist/sap/ui/core/format/DateFormat.js

@@ -1,13 +1,15 @@
-import Core from '../Core.js';
 import CalendarType from '../CalendarType.js';
 import Locale from '../Locale.js';
 import LocaleData from '../LocaleData.js';
 import UniversalDate from '../date/UniversalDate.js';
+import CalendarUtils from '../date/CalendarUtils.js';
+import CalendarWeekNumbering from '../date/CalendarWeekNumbering.js';
 import TimezoneUtil from './TimezoneUtil.js';
 import deepEqual from '../../../base/util/deepEqual.js';
 import formatMessage from '../../../base/strings/formatMessage.js';
 import Log from '../../../base/Log.js';
 import extend from '../../../base/util/extend.js';
+import Configuration from '../Configuration.js';
 var DateFormat = function () {
     throw new Error();
 };
@@ -263,7 +265,7 @@ DateFormat.createInstance = function (oFormatOptions, oLocale, oInfo) {
         oFormatOptions = undefined;
     }
     if (!oLocale) {
-        oLocale = Core.getConfiguration().getFormatSettings().getFormatLocale();
+        oLocale = Configuration.getFormatSettings().getFormatLocale();
     }
     oFormat.oLocale = oLocale;
     oFormat.oLocaleData = LocaleData.getInstance(oLocale);
@@ -279,7 +281,13 @@ DateFormat.createInstance = function (oFormatOptions, oLocale, oInfo) {
     }
     oFormat.type = oInfo.type;
     if (!oFormat.oFormatOptions.calendarType) {
-        oFormat.oFormatOptions.calendarType = Core.getConfiguration().getCalendarType();
+        oFormat.oFormatOptions.calendarType = Configuration.getCalendarType();
+    }
+    if (oFormat.oFormatOptions.firstDayOfWeek === undefined && oFormat.oFormatOptions.minimalDaysInFirstWeek !== undefined || oFormat.oFormatOptions.firstDayOfWeek !== undefined && oFormat.oFormatOptions.minimalDaysInFirstWeek === undefined) {
+        throw new TypeError('Format options firstDayOfWeek and minimalDaysInFirstWeek need both to be set, but only one was provided.');
+    }
+    if (oFormat.oFormatOptions.calendarWeekNumbering && !Object.values(CalendarWeekNumbering).includes(oFormat.oFormatOptions.calendarWeekNumbering)) {
+        throw new TypeError('Illegal format option calendarWeekNumbering: \'' + oFormat.oFormatOptions.calendarWeekNumbering + '\'');
     }
     if (!oFormat.oFormatOptions.pattern) {
         if (oFormat.oFormatOptions.format) {
@@ -361,7 +369,15 @@ DateFormat.prototype.init = function () {
     this.aErasNarrow = this.oLocaleData.getEras('narrow', sCalendarType);
     this.aErasAbbrev = this.oLocaleData.getEras('abbreviated', sCalendarType);
     this.aErasWide = this.oLocaleData.getEras('wide', sCalendarType);
-    this.aDayPeriods = this.oLocaleData.getDayPeriods('abbreviated', sCalendarType);
+    this.aDayPeriodsAbbrev = this.oLocaleData.getDayPeriods('abbreviated', sCalendarType);
+    this.aDayPeriodsNarrow = this.oLocaleData.getDayPeriods('narrow', sCalendarType);
+    this.aDayPeriodsWide = this.oLocaleData.getDayPeriods('wide', sCalendarType);
+    this.oFlexibleDayPeriodsAbbrev = this.oLocaleData.getFlexibleDayPeriods('abbreviated', sCalendarType);
+    this.oFlexibleDayPeriodsNarrow = this.oLocaleData.getFlexibleDayPeriods('narrow', sCalendarType);
+    this.oFlexibleDayPeriodsWide = this.oLocaleData.getFlexibleDayPeriods('wide', sCalendarType);
+    this.oFlexibleDayPeriodsAbbrevSt = this.oLocaleData.getFlexibleDayPeriodsStandAlone('abbreviated', sCalendarType);
+    this.oFlexibleDayPeriodsNarrowSt = this.oLocaleData.getFlexibleDayPeriodsStandAlone('narrow', sCalendarType);
+    this.oFlexibleDayPeriodsWideSt = this.oLocaleData.getFlexibleDayPeriodsStandAlone('wide', sCalendarType);
     this.aFormatArray = this.parseCldrDatePattern(this.oFormatOptions.pattern);
     this.sAllowedCharacters = this.getAllowedCharacters(this.aFormatArray);
 };
@@ -601,7 +617,7 @@ DateFormat.prototype.oSymbols = {
     'Y': {
         name: 'weekYear',
         format: function (oField, oDate, bUTC, oFormat) {
-            var oWeek = oDate.getUTCWeek();
+            var oWeek = oDate.getUTCWeek(oFormat.oLocale, getCalendarWeekParameter(oFormat.oFormatOptions));
             var iWeekYear = oWeek.year;
             var sWeekYear = String(iWeekYear);
             var sCalendarType = oFormat.oFormatOptions.calendarType;
@@ -752,7 +768,7 @@ DateFormat.prototype.oSymbols = {
     'w': {
         name: 'weekInYear',
         format: function (oField, oDate, bUTC, oFormat) {
-            var oWeek = oDate.getUTCWeek();
+            var oWeek = oDate.getUTCWeek(oFormat.oLocale, getCalendarWeekParameter(oFormat.oFormatOptions));
             var iWeek = oWeek.week;
             var sWeek = String(iWeek + 1);
             if (oField.digits < 3) {
@@ -1034,35 +1050,89 @@ DateFormat.prototype.oSymbols = {
         name: 'amPmMarker',
         format: function (oField, oDate, bUTC, oFormat) {
             var iDayPeriod = oDate.getUTCDayPeriod();
-            return oFormat.aDayPeriods[iDayPeriod];
+            if (oField.digits <= 3) {
+                return oFormat.aDayPeriodsAbbrev[iDayPeriod];
+            } else if (oField.digits === 4) {
+                return oFormat.aDayPeriodsWide[iDayPeriod];
+            } else {
+                return oFormat.aDayPeriodsNarrow[iDayPeriod];
+            }
+        },
+        parse: function (sValue, oPart, oFormat, oConfig, sTimezone) {
+            var rAMPM, bAMPMAlternativeCase, oEntry, i, aMatch, normalize, aVariants, aDayPeriodsVariants = [
+                    oFormat.aDayPeriodsWide,
+                    oFormat.aDayPeriodsAbbrev,
+                    oFormat.aDayPeriodsNarrow
+                ];
+            rAMPM = /[aApP](?:\.)?[\x20\xA0]?[mM](?:\.)?/;
+            aMatch = sValue.match(rAMPM);
+            bAMPMAlternativeCase = aMatch && aMatch.index === 0;
+            function normalize(sValue) {
+                return sValue.replace(/[\x20\xA0]/g, '').replace(/\./g, '');
+            }
+            if (bAMPMAlternativeCase) {
+                sValue = normalize(sValue);
+            }
+            for (i = 0; i < aDayPeriodsVariants.length; i += 1) {
+                aVariants = aDayPeriodsVariants[i];
+                if (bAMPMAlternativeCase) {
+                    aVariants = aVariants.map(normalize);
+                }
+                oEntry = oParseHelper.findEntry(sValue, aVariants, oFormat.oLocaleData.sCLDRLocaleId);
+                if (oEntry.index !== -1) {
+                    return {
+                        pm: oEntry.index === 1,
+                        length: bAMPMAlternativeCase ? aMatch[0].length : oEntry.length
+                    };
+                }
+            }
+            return { valid: false };
+        }
+    },
+    'B': {
+        name: 'flexibleDayPeriod',
+        format: function (oField, oDate, bUTC, oFormat) {
+            var bContainsHour = oFormat.aFormatArray.some(function (oFormatElement) {
+                    return 'hHKk'.includes(oFormatElement.symbol);
+                }), sFlexibleDayPeriod = oFormat.oLocaleData.getFlexibleDayPeriodOfTime(oDate.getUTCHours(), oDate.getUTCMinutes());
+            if (bContainsHour) {
+                if (oField.digits <= 3) {
+                    return oFormat.oFlexibleDayPeriodsAbbrev[sFlexibleDayPeriod];
+                }
+                if (oField.digits === 4) {
+                    return oFormat.oFlexibleDayPeriodsWide[sFlexibleDayPeriod];
+                }
+                return oFormat.oFlexibleDayPeriodsNarrow[sFlexibleDayPeriod];
+            }
+            if (oField.digits <= 3) {
+                return oFormat.oFlexibleDayPeriodsAbbrevSt[sFlexibleDayPeriod];
+            }
+            if (oField.digits === 4) {
+                return oFormat.oFlexibleDayPeriodsWideSt[sFlexibleDayPeriod];
+            }
+            return oFormat.oFlexibleDayPeriodsNarrowSt[sFlexibleDayPeriod];
         },
         parse: function (sValue, oPart, oFormat, oConfig) {
-            var bPM;
-            var iLength;
-            var sAM = oFormat.aDayPeriods[0], sPM = oFormat.aDayPeriods[1];
-            var rAMPM = /[aApP](?:\.)?[\x20\xA0]?[mM](?:\.)?/;
-            var aMatch = sValue.match(rAMPM);
-            var bVariant = aMatch && aMatch.index === 0;
-            if (bVariant) {
-                sValue = aMatch[0];
-                sAM = sAM.replace(/[\x20\xA0]/g, '');
-                sPM = sPM.replace(/[\x20\xA0]/g, '');
-                sValue = sValue.replace(/[\x20\xA0]/g, '');
-                sAM = sAM.replace(/\./g, '').toLowerCase();
-                sPM = sPM.replace(/\./g, '').toLowerCase();
-                sValue = sValue.replace(/\./g, '').toLowerCase();
-            }
-            if (sValue.indexOf(sAM) === 0) {
-                bPM = false;
-                iLength = bVariant ? aMatch[0].length : sAM.length;
-            } else if (sValue.indexOf(sPM) === 0) {
-                bPM = true;
-                iLength = bVariant ? aMatch[0].length : sPM.length;
+            var i, oFound, oVariant, bContainsHour = oFormat.aFormatArray.some(function (oFormatElement) {
+                    return 'hHKk'.includes(oFormatElement.symbol);
+                }), aFlexibleDayPeriodVariants = [
+                    oFormat.oFlexibleDayPeriodsWide,
+                    oFormat.oFlexibleDayPeriodsAbbrev,
+                    oFormat.oFlexibleDayPeriodsNarrow
+                ];
+            if (bContainsHour) {
+                for (i = 0; i < aFlexibleDayPeriodVariants.length; i++) {
+                    oVariant = aFlexibleDayPeriodVariants[i];
+                    oFound = oParseHelper.findEntry(sValue, Object.values(oVariant), oFormat.oLocaleData.sCLDRLocaleId);
+                    if (oFound.index !== -1) {
+                        return {
+                            flexDayPeriod: Object.keys(oVariant)[oFound.index],
+                            length: oFound.length
+                        };
+                    }
+                }
             }
-            return {
-                pm: bPM,
-                length: iLength
-            };
+            return { valid: false };
         }
     },
     'H': {
@@ -1338,7 +1408,7 @@ DateFormat.prototype.oSymbols = {
         name: 'timezoneID',
         format: function (oField, oDate, bUTC, oFormat, sTimezone) {
             if (!bUTC && oField.digits === 2) {
-                return sTimezone;
+                return oFormat.oLocaleData.getTimezoneTranslations()[sTimezone] || sTimezone;
             }
             return '';
         },
@@ -1348,18 +1418,27 @@ DateFormat.prototype.oSymbols = {
                 length: 0
             };
             if (oPart.digits === 2) {
-                if (sValue === sTimezone) {
-                    oTimezoneParsed.timezone = sTimezone;
-                    oTimezoneParsed.length = sTimezone.length;
-                    return oTimezoneParsed;
+                var mTimezoneTranslations = oFormat.oLocaleData.getTimezoneTranslations();
+                if (sValue === mTimezoneTranslations[sTimezone]) {
+                    return {
+                        timezone: sTimezone,
+                        length: sValue.length
+                    };
                 }
-                if (sValue) {
-                    var rIanaTimezone = new RegExp('([A-Za-z_])+([/][A-Za-z_]+)+');
-                    var aResult = rIanaTimezone.exec(sValue);
-                    if (aResult && aResult[0] && TimezoneUtil.isValidTimezone(aResult[0])) {
-                        oTimezoneParsed.timezone = aResult[0];
-                        oTimezoneParsed.length = aResult[0].length;
-                        return oTimezoneParsed;
+                var aTimezoneTranslations = Object.values(mTimezoneTranslations);
+                var oTimezoneResult = oParseHelper.findEntry(sValue, aTimezoneTranslations, oFormat.oLocaleData.sCLDRLocaleId);
+                if (oTimezoneResult.index !== -1) {
+                    return {
+                        timezone: Object.keys(mTimezoneTranslations)[oTimezoneResult.index],
+                        length: oTimezoneResult.length
+                    };
+                }
+                var sCurrentValue = '';
+                for (var i = 0; i < sValue.length; i++) {
+                    sCurrentValue += sValue[i];
+                    if (TimezoneUtil.isValidTimezone(sCurrentValue)) {
+                        oTimezoneParsed.timezone = sCurrentValue;
+                        oTimezoneParsed.length = sCurrentValue.length;
                     }
                 }
             }
@@ -1383,7 +1462,7 @@ DateFormat.prototype._format = function (oJSDate, bUTC, sTimezone) {
         aBuffer.push(this.oSymbols[sSymbol].format(oPart, oDate, bUTC, this, sTimezone));
     }
     sResult = aBuffer.join('');
-    if (Core.getConfiguration().getOriginInfo()) {
+    if (Configuration.getOriginInfo()) {
         sResult = new String(sResult);
         sResult.originInfo = {
             source: 'Common Locale Data Repository',
@@ -1409,7 +1488,7 @@ DateFormat.prototype.format = function (vJSDate, bUTC) {
     if (bUTC === undefined) {
         bUTC = this.oFormatOptions.UTC;
     }
-    sTimezone = sTimezone || Core.getConfiguration().getTimezone();
+    sTimezone = sTimezone || Configuration.getTimezone();
     if (Array.isArray(vJSDate)) {
         if (!this.oFormatOptions.interval) {
             Log.error('Non-interval DateFormat can\'t format more than one date instance.');
@@ -1441,7 +1520,7 @@ DateFormat.prototype.format = function (vJSDate, bUTC) {
     } else {
         if (!isValidDateObject(vJSDate)) {
             if (this.type === mDateFormatTypes.DATETIME_WITH_TIMEZONE && this.oFormatOptions.pattern.includes('VV')) {
-                return sTimezone;
+                return this.oLocaleData.getTimezoneTranslations()[sTimezone] || sTimezone;
             }
             Log.error('The given date instance isn\'t valid.');
             return '';
@@ -1519,7 +1598,7 @@ DateFormat.prototype._getGreatestDiffField = function (aDates) {
     return null;
 };
 DateFormat.prototype._parse = function (sValue, aFormatArray, bUTC, bStrict, sTimezone) {
-    var iIndex = 0, oPart, sSubValue, oResult;
+    var iIndex = 0, sFlexibleDayPeriod, oPart, bPM, sSubValue, oResult;
     var oDateValue = {
         valid: true,
         lastTimezonePatternSymbol: ''
@@ -1544,7 +1623,12 @@ DateFormat.prototype._parse = function (sValue, aFormatArray, bUTC, bStrict, sTi
         iIndex += oResult.length || 0;
     }
     oDateValue.index = iIndex;
-    if (oDateValue.pm) {
+    bPM = oDateValue.pm;
+    if (oDateValue.flexDayPeriod && oDateValue.hour * 60 + (oDateValue.minute || 0) < 720) {
+        sFlexibleDayPeriod = this.oLocaleData.getFlexibleDayPeriodOfTime(oDateValue.hour + 12, oDateValue.minute || 0);
+        bPM = oDateValue.flexDayPeriod === sFlexibleDayPeriod;
+    }
+    if (bPM) {
         oDateValue.hour += 12;
     }
     if (oDateValue.dayNumberOfWeek === undefined && oDateValue.dayOfWeek !== undefined) {
@@ -1601,13 +1685,24 @@ DateFormat.prototype._parseInterval = function (sValue, sCalendarType, bUTC, bSt
     }.bind(this));
     return aDateValues;
 };
+function getCalendarWeekParameter(oFormatOptions) {
+    if (oFormatOptions.calendarWeekNumbering) {
+        return oFormatOptions.calendarWeekNumbering;
+    } else if (oFormatOptions.firstDayOfWeek !== undefined && oFormatOptions.minimalDaysInFirstWeek !== undefined) {
+        return {
+            firstDayOfWeek: oFormatOptions.firstDayOfWeek,
+            minimalDaysInFirstWeek: oFormatOptions.minimalDaysInFirstWeek
+        };
+    }
+    return undefined;
+}
 var convertToTimezone = function (oJSDate, sTimezone, bUTC) {
     if (!bUTC && isValidDateObject(oJSDate)) {
         return TimezoneUtil.convertToTimezone(oJSDate, sTimezone);
     }
     return oJSDate;
 };
-var fnCreateDate = function (oDateValue, sCalendarType, bUTC, bStrict, sTimezone) {
+var fnCreateDate = function (oDateValue, sCalendarType, bUTC, bStrict, sTimezone, oFormatOptions, oLocale) {
     if (!oDateValue.valid) {
         return null;
     }
@@ -1628,7 +1723,7 @@ var fnCreateDate = function (oDateValue, sCalendarType, bUTC, bStrict, sTimezone
         oDate.setUTCWeek({
             year: oDateValue.weekYear || oDateValue.year,
             week: oDateValue.week
-        });
+        }, oLocale, getCalendarWeekParameter(oFormatOptions));
         if (oDateValue.dayNumberOfWeek !== undefined) {
             oDate.setUTCDate(oDate.getUTCDate() + oDateValue.dayNumberOfWeek - 1);
         }
@@ -1643,7 +1738,7 @@ var fnCreateDate = function (oDateValue, sCalendarType, bUTC, bStrict, sTimezone
         }
     }
     if (oDateValue.tzDiff) {
-        oDate.setUTCSeconds((oDateValue.second || 0) + oDateValue.tzDiff);
+        oDate.setUTCSeconds(oDate.getUTCSeconds() + oDateValue.tzDiff);
     }
     return oDate;
 };
@@ -1694,7 +1789,7 @@ DateFormat.prototype.parse = function (sValue, bUTC, bStrict) {
     sValue = sValue == null ? '' : String(sValue).trim();
     var oDateValue;
     var sCalendarType = this.oFormatOptions.calendarType;
-    sTimezone = sTimezone || Core.getConfiguration().getTimezone();
+    sTimezone = sTimezone || Configuration.getTimezone();
     if (bStrict === undefined) {
         bStrict = this.oFormatOptions.strictParsing;
     }
@@ -1710,7 +1805,7 @@ DateFormat.prototype.parse = function (sValue, bUTC, bStrict) {
         if (oDateValue.index === 0 || oDateValue.index < sValue.length) {
             oDateValue.valid = false;
         }
-        oJSDate = fnCreateDate(oDateValue, sCalendarType, bUTC, bStrict, sTimezone);
+        oJSDate = fnCreateDate(oDateValue, sCalendarType, bUTC, bStrict, sTimezone, this.oFormatOptions, this.oLocale);
         if (oJSDate) {
             if (this.type === mDateFormatTypes.DATETIME_WITH_TIMEZONE) {
                 var bShowTimezone = this.oFormatOptions.showTimezone === undefined || this.oFormatOptions.showTimezone;
@@ -1738,8 +1833,8 @@ DateFormat.prototype.parse = function (sValue, bUTC, bStrict) {
         if (aDateValues && aDateValues.length == 2) {
             var oDateValue1 = mergeWithoutOverwrite(aDateValues[0], aDateValues[1]);
             var oDateValue2 = mergeWithoutOverwrite(aDateValues[1], aDateValues[0]);
-            oJSDate1 = fnCreateDate(oDateValue1, sCalendarType, bUTC, bStrict, sTimezone);
-            oJSDate2 = fnCreateDate(oDateValue2, sCalendarType, bUTC, bStrict, sTimezone);
+            oJSDate1 = fnCreateDate(oDateValue1, sCalendarType, bUTC, bStrict, sTimezone, this.oFormatOptions, this.oLocale);
+            oJSDate2 = fnCreateDate(oDateValue2, sCalendarType, bUTC, bStrict, sTimezone, this.oFormatOptions, this.oLocale);
             if (oJSDate1 && oJSDate2) {
                 if (this.oFormatOptions.singleIntervalValue && oJSDate1.getTime() === oJSDate2.getTime()) {
                     return [
@@ -2067,7 +2162,12 @@ var mRelativeDiffs = {
     }
 };
 DateFormat.prototype._adaptDayOfWeek = function (iDayOfWeek) {
-    var iFirstDayOfWeek = LocaleData.getInstance(Core.getConfiguration().getFormatSettings().getFormatLocale()).getFirstDayOfWeek();
+    var vCalendarWeekParameter = getCalendarWeekParameter(this.oFormatOptions), iFirstDayOfWeek;
+    if (typeof vCalendarWeekParameter === 'object') {
+        iFirstDayOfWeek = vCalendarWeekParameter.firstDayOfWeek;
+    } else {
+        iFirstDayOfWeek = CalendarUtils.getWeekConfigurationValues(vCalendarWeekParameter, this.oLocale).firstDayOfWeek;
+    }
     var iDayNumberOfWeek = iDayOfWeek - (iFirstDayOfWeek - 1);
     if (iDayNumberOfWeek <= 0) {
         iDayNumberOfWeek += 7;

package/dist/sap/ui/core/format/TimezoneUtil.js

@@ -1,5 +1,6 @@
 var TimezoneUtil = {};
 var sLocalTimezone = "";
+var aSupportedTimezoneIDs;
 var oIntlDateTimeFormatCache = {
   _oCache: new Map(),
   _iCacheLimit: 10,
@@ -33,6 +34,16 @@ TimezoneUtil.isValidTimezone = function (sTimezone) {
   if (!sTimezone) {
     return false;
   }
+  if (Intl.supportedValuesOf) {
+    try {
+      aSupportedTimezoneIDs = aSupportedTimezoneIDs || Intl.supportedValuesOf("timeZone");
+      if (aSupportedTimezoneIDs.includes(sTimezone)) {
+        return true;
+      }
+    } catch (oError) {
+      aSupportedTimezoneIDs = [];
+    }
+  }
   try {
     oIntlDateTimeFormatCache.get(sTimezone);
     return true;
@@ -63,7 +74,7 @@ TimezoneUtil._getDateFromParts = function (oParts) {
     iUTCYear = iUTCYear * -1 + 1;
   }
   oDate.setUTCFullYear(iUTCYear, parseInt(oParts.month) - 1, parseInt(oParts.day));
-  oDate.setUTCHours(parseInt(oParts.hour), parseInt(oParts.minute), parseInt(oParts.second), parseInt(oParts.fractionalSecond));
+  oDate.setUTCHours(parseInt(oParts.hour), parseInt(oParts.minute), parseInt(oParts.second), parseInt(oParts.fractionalSecond || 0));
   return oDate;
 };
 TimezoneUtil.calculateOffset = function (oDate, sTimezoneSource) {

package/package-scripts.js

@@ -5,25 +5,28 @@ const esmAbsToRel = resolve.sync("@ui5/webcomponents-tools/lib/esm-abs-to-rel/in
 
 const scripts = {
 	clean: "rimraf dist",
-	lint: "eslint . --config config/.eslintrc.js",
+	lint: "cross-env UI5_TS=true eslint . --config config/.eslintrc.js",
 	build: {
-		"default": "nps lint clean copy.used-modules copy.cldr copy.overlay build.replace-amd build.replace-export-true build.replace-export-false build.amd-to-es6 build.replace-global-core-usage build.esm-abs-to-rel build.jsonImports copy.src",
+		"default": "nps lint clean copy.used-modules copy.cldr copy.overlay build.replace-amd build.replace-export-true build.replace-export-false build.amd-to-es6 build.replace-global-core-usage build.esm-abs-to-rel build.jsonImports build.typescript copy.src",
 		"replace-amd": "replace-in-file sap.ui.define define dist/**/*.js",
 		"replace-export-true": `replace-in-file ", /* bExport= */ true" "" dist/**/*.js`,
 		"replace-export-false": `replace-in-file ", /* bExport= */ false" "" dist/**/*.js`,
 		"amd-to-es6": "amdtoes6 --src=dist --replace --glob=**/*.js",
 		"replace-global-core-usage": `node "${replaceGlobalCore}" dist/`,
 		"esm-abs-to-rel": `node "${esmAbsToRel}" dist/`,
+		typescript: "tsc",
 		jsonImports: "node ./lib/generate-json-imports/cldr.js"
 	},
+	typescript: "tsc",
 	copy: {
 		"used-modules": `node "${copyUsedModules}" ./used-modules.txt dist/`,
-		cldr: `copy-and-watch "../../node_modules/@openui5/sap.ui.core/src/sap/ui/core/cldr/*.json" dist/generated/assets/cldr/`,
+		cldr: `node ./lib/copy-and-strip-cldr/index.js "../../node_modules/@openui5/sap.ui.core/src/sap/ui/core/cldr/" dist/generated/assets/cldr/`,
 		overlay: `copy-and-watch "overlay/**/*.js" dist/`,
 		src: `copy-and-watch "src/**/*.js" dist/`,
 	},
 	watch: {
-		default: 'nps watch.src',
+		default: 'concurrently "nps watch.src" "nps watch.typescript" ',
+		typescript: "tsc --watch",
 		src: `nps "copy.src --watch --skip-initial-copy"`,
 	},
 	start: "nps watch",