@qooxdoo/framework 7.9.1 → 8.0.0-beta.1

package/source/class/qx/locale/Date.js

@@ -15,6 +15,7 @@
      * Sebastian Werner (wpbasti)
      * Andreas Ecker (ecker)
      * Fabian Jakobs (fjakobs)
+     * Dmitrii Zolotov (goldim)
 
 ************************************************************************ */
 
@@ -22,7 +23,9 @@
  * Static class that provides localized date information (like names of week
  * days, AM/PM markers, start of week, etc.).
  *
- * @cldr()
+ * @ignore(Intl.DateTimeFormat)
+ * @ignore(Intl.Locale)
+ * @ignore(Intl)
  */
 qx.Class.define("qx.locale.Date", {
   statics: {
@@ -40,7 +43,7 @@ qx.Class.define("qx.locale.Date", {
      * @return {String} translated AM marker.
      */
     getAmMarker(locale) {
-      return this.__mgr.localize("cldr_am", [], locale);
+      return this.__localizeMarker("am", 1, locale);
     },
 
     /**
@@ -50,7 +53,35 @@ qx.Class.define("qx.locale.Date", {
      * @return {String} translated PM marker.
      */
     getPmMarker(locale) {
-      return this.__mgr.localize("cldr_pm", [], locale);
+      return this.__localizeMarker("pm", 12, locale);
+    },
+
+    /**
+     * Localize day period/marker of a month
+     *
+     * @param {String} id LocalizedString Id
+     * @param {Integer} month index of the month. 0=january, 1=february, ...
+     * @param {String} locale optional locale to be used
+     * @returns {qx.locale.LocalizedString} localized day marker
+     */
+    __localizeMarker(id, month, locale) {
+      locale = this.__transformLocale(locale);
+      const date = new Date();
+      date.setHours(month);
+      const timeOptions = {
+        hour: "numeric",
+        minute: "numeric",
+        hour12: true
+      };
+      const timeParts = Intl.DateTimeFormat(locale, timeOptions).formatToParts(
+        date
+      );
+      const found = timeParts.find(part => part.type === "dayPeriod");
+      let value;
+      if (found) {
+        value = found.value;
+      }
+      return new qx.locale.LocalizedString(value, "cldr_" + id, [], true);
     },
 
     /**
@@ -66,32 +97,42 @@ qx.Class.define("qx.locale.Date", {
      * @return {String[]} array of localized day names starting with sunday.
      */
     getDayNames(length, locale, context, withFallback) {
-      var context = context ? context : "format";
+      context = context ? context : "format";
 
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertInArray(length, ["abbreviated", "narrow", "wide"]);
         qx.core.Assert.assertInArray(context, ["format", "stand-alone"]);
       }
 
-      var days = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
-
-      var names = [];
-
-      for (var i = 0; i < days.length; i++) {
-        var key = "cldr_day_" + context + "_" + length + "_" + days[i];
-        names.push(
+      let days = [];
+      for (let i = 0; i < 7; i++) {
+        const localizedDay = this.getDayName(
+          length,
+          i,
+          locale,
+          context,
           withFallback
-            ? this.__localizeWithFallback(
-                context,
-                context === "format" ? "stand-alone" : "format",
-                key,
-                locale
-              )
-            : this.__mgr.localize(key, [], locale)
         );
+        days.push(localizedDay);
       }
+      return days;
+    },
 
-      return names;
+    /**
+     * Returns weekday for day of month
+     *
+     * @param {Integer} day day of month
+     * @param {String} id LocalizedString id
+     * @param {String} locale locale to be used
+     * @param {object} options date/time Intl API options
+     * @returns {qx.locale.LocalizedString} localized weekday
+     */
+    __getWeekdayFromDay(day, id, locale, options) {
+      const parts = new Intl.DateTimeFormat(locale, options).formatToParts(
+        new Date(Date.UTC(2021, 10, day))
+      );
+      const value = parts.find(part => part.type === "weekday")?.value;
+      return new qx.locale.LocalizedString(value, id, [], true);
     },
 
     /**
@@ -108,7 +149,7 @@ qx.Class.define("qx.locale.Date", {
      * @return {String} localized day name
      */
     getDayName(length, day, locale, context, withFallback) {
-      var context = context ? context : "format";
+      context = context ? context : "format";
 
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertInArray(length, ["abbreviated", "narrow", "wide"]);
@@ -117,17 +158,26 @@ qx.Class.define("qx.locale.Date", {
         qx.core.Assert.assertInArray(context, ["format", "stand-alone"]);
       }
 
-      var days = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
-
-      var key = "cldr_day_" + context + "_" + length + "_" + days[day];
-      return withFallback
-        ? this.__localizeWithFallback(
-            context,
-            context === "format" ? "stand-alone" : "format",
-            key,
-            locale
-          )
-        : this.__mgr.localize(key, [], locale);
+      let weekFormat = "short";
+      if (length === "narrow") {
+        weekFormat = "narrow";
+      } else if (length === "wide") {
+        weekFormat = "long";
+      }
+
+      const options = { weekday: weekFormat };
+      if (context === "format") {
+        options.day = "numeric";
+      }
+
+      locale = this.__transformLocale(locale);
+      const days = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+      return this.__getWeekdayFromDay(
+        day,
+        "cldr_day_" + context + "_" + length + "_" + days[day],
+        locale,
+        options
+      );
     },
 
     /**
@@ -143,30 +193,42 @@ qx.Class.define("qx.locale.Date", {
      * @return {String[]} array of localized month names starting with january.
      */
     getMonthNames(length, locale, context, withFallback) {
-      var context = context ? context : "format";
+      context = context ? context : "format";
 
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertInArray(length, ["abbreviated", "narrow", "wide"]);
         qx.core.Assert.assertInArray(context, ["format", "stand-alone"]);
       }
 
-      var names = [];
-
-      for (var i = 0; i < 12; i++) {
-        var key = "cldr_month_" + context + "_" + length + "_" + (i + 1);
-        names.push(
+      const months = [];
+      for (let i = 0; i < 12; i++) {
+        const localizedMonth = this.getMonthName(
+          length,
+          i,
+          locale,
+          context,
           withFallback
-            ? this.__localizeWithFallback(
-                context,
-                context === "format" ? "stand-alone" : "format",
-                key,
-                locale
-              )
-            : this.__mgr.localize(key, [], locale)
         );
+        months.push(localizedMonth);
       }
+      return months;
+    },
 
-      return names;
+    /**
+     * Localize month
+     *
+     * @param {Integer} month index of the month. 0=january, 1=february, ...
+     * @param {String} id LocalizedString id
+     * @param {String} locale locale to be used
+     * @param {object} options Intl API date/time options
+     * @returns {qx.locale.LocalizedString} localized string
+     */
+    __localizeMonth(month, id, locale, options) {
+      const parts = new Intl.DateTimeFormat(locale, options).formatToParts(
+        new Date(2000, month, 1)
+      );
+      const value = parts.find(part => part.type === "month")?.value;
+      return new qx.locale.LocalizedString(value, id, [], true);
     },
 
     /**
@@ -183,22 +245,27 @@ qx.Class.define("qx.locale.Date", {
      * @return {String} localized month name
      */
     getMonthName(length, month, locale, context, withFallback) {
-      var context = context ? context : "format";
+      context = context ? context : "format";
 
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertInArray(length, ["abbreviated", "narrow", "wide"]);
         qx.core.Assert.assertInArray(context, ["format", "stand-alone"]);
       }
 
-      var key = "cldr_month_" + context + "_" + length + "_" + (month + 1);
-      return withFallback
-        ? this.__localizeWithFallback(
-            context,
-            context === "format" ? "stand-alone" : "format",
-            key,
-            locale
-          )
-        : this.__mgr.localize(key, [], locale);
+      let monthLength = "short";
+      if (length === "narrow") {
+        monthLength = "narrow";
+      } else if (length === "wide") {
+        monthLength = "long";
+      }
+
+      const options = { month: monthLength };
+      if (context === "format") {
+        options.day = "numeric";
+      }
+      locale = this.__transformLocale(locale);
+      const id = "cldr_month_" + context + "_" + length + "_" + (month + 1);
+      return this.__localizeMonth(month, id, locale, options);
     },
 
     /**
@@ -213,9 +280,83 @@ qx.Class.define("qx.locale.Date", {
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertInArray(size, ["short", "medium", "long", "full"]);
       }
+      locale = this.__transformLocale(locale);
+      var id = "cldr_date_format_" + size;
+      return this.__localizeDate(id, locale, { dateStyle: size });
+    },
 
-      var key = "cldr_date_format_" + size;
-      return this.__mgr.localize(key, [], locale);
+    /**
+     * Localize date via Intl API
+     *
+     * @param {String} id LocalizedString id
+     * @param {String} locale locale to be used
+     * @param {object} options date/time Intl API options
+     * @returns {qx.locale.LocalizedString} localized date
+     */
+    __localizeDate(id, locale, options) {
+      const parts = new Intl.DateTimeFormat(locale, { ...options, calendar: "gregory" }).formatToParts(
+        new Date(2000, 1, 1)
+      );
+      const nonLiteralPartCount = parts.filter(
+        part => part.type !== "literal"
+      ).length;
+      const result = [];
+
+      for (let part of parts) {
+        let value = part.value;
+        let type = part.type;
+        let length = value.length;
+        let lexem = "";
+
+        if (part.type === "year") {
+          if (length === 4) {
+            lexem = "y";
+          } else if (length === 2) {
+            lexem = "yy";
+          } else {
+            lexem = "y".repeat(length);
+          }
+        } else if (type === "month") {
+          let letter = nonLiteralPartCount === 1 ? "L" : "M";
+          const parsedValue = parseInt(value);
+          if (!isNaN(parsedValue)) {
+            lexem = letter.repeat(length);
+          } else {
+            let context = nonLiteralPartCount === 1 ? "stand-alone" : "format";
+            let monthShort = this.getMonthName(
+              "abbreviated",
+              1,
+              locale,
+              context
+            ).toString();
+            if (monthShort === value) {
+              lexem = letter.repeat(3);
+            } else {
+              let monthLong = this.getMonthName(
+                "wide",
+                1,
+                locale,
+                context
+              ).toString();
+              if (monthLong === value) {
+                lexem = letter.repeat(4);
+              }
+            }
+          }
+        } else if (type === "literal") {
+          lexem = value;
+        } else if (type === "day") {
+          lexem = "d";
+        } else if (type === "weekday") {
+          if (value === this.getDayName("wide", 2, locale).toString()) {
+            lexem = "EEEE";
+          } else {
+            lexem = "E";
+          }
+        }
+        result.push(lexem);
+      }
+      return new qx.locale.LocalizedString(result.join(""), id, [], true);
     },
 
     /**
@@ -229,19 +370,212 @@ qx.Class.define("qx.locale.Date", {
      *       Examples are "yyyyMMMM" for year + full month, or "MMMd" for abbreviated month + day.
      * @param fallback {String} fallback format string if no localized version is found
      * @param locale {String} optional locale to be used
-     * @return {String} best matching format string
+     * @return {qx.locale.LocalizedString} best matching format string
      */
     getDateTimeFormat(canonical, fallback, locale) {
-      var key = "cldr_date_time_format_" + canonical;
-      var localizedFormat = this.__mgr.localize(key, [], locale);
+      locale = this.__transformLocale(locale);
+
+      const id = "cldr_date_time_format_" + canonical;
+      const dateLocaleTable = {
+        d: { day: "2-digit" },
+        y: { year: "numeric" },
+        M: { month: "numeric" },
+        MMM: { month: "short" },
+        MMMd: { day: "numeric", month: "short" },
+        yMMM: { year: "numeric", month: "short" },
+        Ed: { weekday: "short", day: "numeric" },
+        Md: { month: "numeric", day: "numeric" },
+        yM: { year: "numeric", month: "numeric" },
+        yMEd: {
+          year: "numeric",
+          month: "numeric",
+          day: "numeric",
+          weekday: "narrow"
+        },
+        yMMMEd: {
+          year: "numeric",
+          month: "short",
+          day: "numeric",
+          weekday: "narrow"
+        },
+        yMMMd: { year: "numeric", month: "short", day: "numeric" },
+        yMd: { year: "numeric", month: "numeric", day: "numeric" },
+        MEd: { month: "numeric", day: "numeric", weekday: "narrow" },
+        MMMEd: { month: "short", day: "numeric", weekday: "narrow" }
+      };
 
-      if (localizedFormat == key) {
+      const timeLocaleTable = {
+        hm: { hour: "numeric", minute: "numeric", hour12: true },
+        Hm: { hour: "2-digit", minute: "2-digit" },
+        ms: { minute: "2-digit", second: "2-digit" },
+        hms: {
+          hour: "numeric",
+          minute: "2-digit",
+          second: "2-digit",
+          hour12: true
+        },
+        Hms: {
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit"
+        }
+      };
+      if (dateLocaleTable.hasOwnProperty(canonical)) {
+        return this.__localizeDate(id, locale, dateLocaleTable[canonical]);
+      }
+      if (timeLocaleTable.hasOwnProperty(canonical)) {
+        return this.__localizeTime(id, locale, timeLocaleTable[canonical]);
+      }
+
+      switch (canonical) {
+        case "yQ":
+          return this.__localizeYQ(id, locale);
+        case "yQQQ":
+          return this.__localizeYQQQ(id, locale);
+      }
+
+      let localizedFormat = this.__mgr.localize(id, [], locale);
+
+      if (localizedFormat == id) {
         localizedFormat = fallback;
       }
 
       return localizedFormat;
     },
 
+    /**
+     * Localize yQ format
+     *
+     * @param {String} id LocalizedString id
+     * @param {String} locale locale to be used
+     * @returns {qx.locale.LocalizedString} localized yQ format
+     */
+    __localizeYQ(id, locale) {
+      const result = "yQ";
+      if (locale === "cy" || locale === "cy-GB") {
+        return "Q y";
+      }
+      return new qx.locale.LocalizedString(result, id, [], true);
+    },
+
+    /**
+     * Localize yQQQ format
+     *
+     * @param {String} id LocalizedString id
+     * @param {String} locale locale to be used
+     * @returns {qx.locale.LocalizedString}
+     */
+    __localizeYQQQ(id, locale) {
+      const mostCase = [
+        "az",
+        "bs-Cyrl",
+        "dz",
+        "ckb",
+        "ii",
+        "kok",
+        "lt",
+        "gu",
+        "haw",
+        "ml",
+        "mni",
+        "my",
+        "ne",
+        "ps",
+        "qu",
+        "rw",
+        "sah",
+        "sd",
+        "se",
+        "seh",
+        "si",
+        "sw",
+        "tk",
+        "to",
+        "tr",
+        "ug",
+        "xh",
+        "yi"
+      ];
+
+      let result = "QQQ y";
+      if (mostCase.includes(locale)) {
+        result = "y QQQ";
+      }
+      switch (locale) {
+        case "ja":
+          result = "y/QQQ";
+          break;
+        case "ka":
+        case "kgp":
+        case "sq":
+          result = "QQQ, y";
+          break;
+        case "kk":
+          result = "y 'ж'. QQQ";
+          break;
+        case "ko":
+          result = "y년 QQQ";
+          break;
+        case "ky":
+          result = "y-'ж'., QQQ";
+          break;
+        case "lv":
+          result = "y. 'g'. QQQ";
+          break;
+        case "mk":
+        case "ru":
+        case "bg":
+          result = "QQQ y 'г'.";
+          break;
+        case "mn":
+          result = "y 'оны' QQQ";
+          break;
+        case "mt":
+          result = "QQQ - y";
+          break;
+        case "pt-PT":
+          result = "QQQQ 'de' y";
+          break;
+        case "pt":
+          result = "QQQ 'de' y";
+          break;
+        case "sr-Latn":
+        case "sr":
+        case "bs":
+        case "hr":
+          result = "QQQ y.";
+          break;
+        case "tt":
+          result = "y 'ел', QQQ";
+          break;
+        case "uz-Cyrl":
+        case "uz":
+          result = "y, QQQ";
+          break;
+        case "yue-Hans":
+        case "yue":
+        case "zh-Hant":
+          result = "y年QQQ";
+          break;
+        case "zh":
+          result = "y年第Q季度";
+          break;
+        case "eu":
+          result = "y('e')'ko' QQQ";
+          break;
+        case "fo":
+          result = "QQQ 'í' y";
+          break;
+        case "hu":
+          result = "y. QQQ";
+          break;
+        case "hy":
+          result = "y թ. QQQ";
+          break;
+      }
+      return new qx.locale.LocalizedString(result, id, [], true);
+    },
+
     /**
      * Return localized time format string to be used with {@link qx.util.format.DateFormat}.
      *
@@ -251,43 +585,107 @@ qx.Class.define("qx.locale.Date", {
      * @return {String} localized time format string
      */
     getTimeFormat(size, locale) {
+      locale = this.__transformLocale(locale);
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertInArray(size, ["short", "medium", "long", "full"]);
       }
 
-      var key = "cldr_time_format_" + size;
-      var localizedFormat = this.__mgr.localize(key, [], locale);
-
-      if (localizedFormat != key) {
-        return localizedFormat;
-      }
-
-      switch (size) {
-        case "short":
-        case "medium":
-          return qx.locale.Date.getDateTimeFormat("HHmm", "HH:mm");
+      return this.__localizeTime("cldr_time_format_" + size, locale, {
+        timeStyle: size
+      });
+    },
 
-        case "long":
-          return qx.locale.Date.getDateTimeFormat("HHmmss", "HH:mm:ss");
+    /**
+     * Localize time via Intl API
+     *
+     * @param {String} id LocalizedString id
+     * @param {String} locale locale to be used
+     * @param {object} options date/time Intl API options
+     * @returns {qx.locale.LocalizedString} localized time
+     */
+    __localizeTime(id, locale, options) {
+      const parts = new Intl.DateTimeFormat(locale, { ...options, calendar: "gregory" }).formatToParts(
+        new Date(2000, 1, 1, 1, 1, 1)
+      );
+      let lexems = [];
+      parts.forEach(part => {
+        let lexem = "";
+        let value = part.value;
+        let length = value.length;
+        switch (part.type) {
+          case "literal":
+            lexem = value;
+            break;
+          case "dayPeriod":
+            lexem = "a";
+            break;
+          case "hour":
+            lexem = this.__getSmallOrBigH(locale, options).repeat(length);
+            break;
+          case "minute":
+            lexem = "m".repeat(length);
+            break;
+          case "second":
+            lexem = "s".repeat(length);
+            break;
+          case "timeZoneName":
+            lexem = this.__getTimezoneFormat(locale, value);
+            break;
+          default:
+            lexem = "";
+        }
+        lexems.push(lexem);
+      });
+
+      let str = lexems.join("").replace(/[\u202F\u00A0]/g, ' ');
+      return new qx.locale.LocalizedString(str, id, [], true);
+    },
 
-        case "full":
-          return qx.locale.Date.getDateTimeFormat("HHmmsszz", "HH:mm:ss zz");
+    /**
+     * Detects what hour format and returns small h if
+     * 24 hour format and big H if 12 hour format
+     *
+     * @param {String} locale locale to be used
+     * @param {object} options date/time Intl API options
+     * @returns {String} h or H
+     */
+    __getSmallOrBigH(locale, options) {
+      const hour24 = new Intl.DateTimeFormat(locale, options)
+        .formatToParts(new Date(2000, 1, 1, 13, 1, 1))
+        .find(subPart => subPart.type === "hour")
+        .value.includes("13");
+      return hour24 ? "h" : "H";
+    },
 
-        default:
-          throw new Error("This case should never happen.");
-      }
+    /**
+     *
+     * @param {String} locale locale to be used
+     * @param {String} value timezone from options
+     * @returns {String} timezone format
+     */
+    __getTimezoneFormat(locale, value) {
+      let short = new Intl.DateTimeFormat(locale, {
+        timeZoneName: "short"
+      })
+        .formatToParts(new Date(2000, 1, 1, 1, 1, 1))
+        .find(part => part.type === "timeZoneName")?.value;
+      return short === value ? "z" : "zzzz";
     },
 
     /**
      * Return the day the week starts with
      *
-     * Reference: Common Locale Data Repository (cldr) supplementalData.xml
-     *
      * @param locale {String} optional locale to be used
      * @return {Integer} index of the first day of the week. 0=sunday, 1=monday, ...
      */
     getWeekStart(locale) {
-      var weekStart = {
+      let intlLocale = this.__transformLocale(locale);
+      if (this.__isIntlWeekInfoSupported(intlLocale)) {
+        let info = new Intl.Locale(intlLocale).weekInfo;
+        return info.firstDay !== 7 ? info.firstDay : 0;
+      }
+      // old implementation
+      const weekStart = {
         // default is monday
         MV: 5, // friday
         AE: 6, // saturday
@@ -355,7 +753,7 @@ qx.Class.define("qx.locale.Date", {
         TJ: 0
       };
 
-      var territory = qx.locale.Date._getTerritory(locale);
+      const territory = qx.locale.Date._getTerritory(locale);
 
       // default is monday
       return weekStart[territory] != null ? weekStart[territory] : 1;
@@ -364,13 +762,17 @@ qx.Class.define("qx.locale.Date", {
     /**
      * Return the day the weekend starts with
      *
-     * Reference: Common Locale Data Repository (cldr) supplementalData.xml
-     *
      * @param locale {String} optional locale to be used
      * @return {Integer} index of the first day of the weekend. 0=sunday, 1=monday, ...
      */
     getWeekendStart(locale) {
-      var weekendStart = {
+      let intlLocale = this.__transformLocale(locale);
+      if (this.__isIntlWeekInfoSupported(intlLocale)) {
+        let info = new Intl.Locale(intlLocale).weekInfo;
+        return info.weekend[0] !== 7 ? info.weekend[0] : 0;
+      }
+      // default is monday
+      const weekendStart = {
         // default is saturday
         EG: 5, // friday
         IL: 5,
@@ -393,7 +795,7 @@ qx.Class.define("qx.locale.Date", {
         YE: 4
       };
 
-      var territory = qx.locale.Date._getTerritory(locale);
+      const territory = qx.locale.Date._getTerritory(locale);
 
       // default is saturday
       return weekendStart[territory] != null ? weekendStart[territory] : 6;
@@ -402,13 +804,18 @@ qx.Class.define("qx.locale.Date", {
     /**
      * Return the day the weekend ends with
      *
-     * Reference: Common Locale Data Repository (cldr) supplementalData.xml
-     *
      * @param locale {String} optional locale to be used
      * @return {Integer} index of the last day of the weekend. 0=sunday, 1=monday, ...
      */
     getWeekendEnd(locale) {
-      var weekendEnd = {
+      let intlLocale = this.__transformLocale(locale);
+      if (this.__isIntlWeekInfoSupported(intlLocale)) {
+        let info = new Intl.Locale(intlLocale).weekInfo;
+        const end = info.weekend[info.weekend.length - 1];
+        return end !== 7 ? end : 0;
+      }
+      // old implementation
+      const weekendEnd = {
         // default is sunday
         AE: 5, // friday
         BH: 5,
@@ -432,7 +839,7 @@ qx.Class.define("qx.locale.Date", {
         SY: 6
       };
 
-      var territory = qx.locale.Date._getTerritory(locale);
+      const territory = qx.locale.Date._getTerritory(locale);
 
       // default is sunday
       return weekendEnd[territory] != null ? weekendEnd[territory] : 0;
@@ -446,8 +853,14 @@ qx.Class.define("qx.locale.Date", {
      * @return {Boolean} whether the given day is a weekend day
      */
     isWeekend(day, locale) {
-      var weekendStart = qx.locale.Date.getWeekendStart(locale);
-      var weekendEnd = qx.locale.Date.getWeekendEnd(locale);
+      let intlLocale = this.__transformLocale(locale);
+      if (this.__isIntlWeekInfoSupported(intlLocale)) {
+        let info = new Intl.Locale(intlLocale).weekInfo;
+        return info.weekend.includes(day !== 0 ? day : 7);
+      }
+      // old implementation
+      const weekendStart = qx.locale.Date.getWeekendStart(locale);
+      const weekendEnd = qx.locale.Date.getWeekendEnd(locale);
 
       if (weekendEnd > weekendStart) {
         return day >= weekendStart && day <= weekendEnd;
@@ -472,30 +885,24 @@ qx.Class.define("qx.locale.Date", {
       return territory.toUpperCase();
     },
 
+    __isIntlWeekInfoSupported(locale){
+      return Intl.Locale && new Intl.Locale(locale).weekInfo;
+    },
+
     /**
-     * Provide localization (CLDR) data with fallback between "format" and "stand-alone" contexts.
-     * It is used in {@link #getDayName} and {@link #getMonthName} methods.
-     *
-     * @param context {String} intended context.
-     *       Possible values: "format", "stand-alone".
-     * @param fallbackContext {String} the context used in case no localization is found for the key.
-     * @param key {String} message id (may contain format strings)
-     * @param locale {String} the locale
-     * @return {String} localized name for the key
+     * Transforms an input locale into locale supported by Intl API
      *
+     * @param locale {String} optional locale to be used
+     * @returns {String} transformed locale
      */
-    __localizeWithFallback(context, fallbackContext, key, locale) {
-      var localizedString = this.__mgr.localize(key, [], locale);
-      if (localizedString == key) {
-        var newKey = key.replace(
-          "_" + context + "_",
-          "_" + fallbackContext + "_"
-        );
-
-        return this.__mgr.localize(newKey, [], locale);
-      } else {
-        return localizedString;
+    __transformLocale(locale) {
+      if (!locale) {
+        locale = this.__mgr.getLocale();
+      }
+      if (locale === "C") {
+        return "en";
       }
+      return locale.replace("_", "-").split('@')[0];
     }
   }
 });