@fr0st/datetime 6.0.1 → 7.0.0

package/src/formatter/tokens.js

@@ -1,5 +1,6 @@
+import { valuesRegExp } from './../helpers.js';
 import { formatDay, formatMonth, formatNumber, formatOffset } from './format.js';
-import { parseDay, parseDayPeriod, parseEra, parseMonth, parseNumber } from './parse.js';
+import { parseDay, parseDayPeriod, parseEra, parseMonth, parseNumber, parseNumberString } from './parse.js';
 import { getType } from './utility.js';
 import { getDayPeriods, getDays, getEras, getMonths, numberRegExp } from './values.js';
 
@@ -13,10 +14,9 @@ export default {
 
     G: {
         key: 'era',
-        maxLength: 5,
         regex: (locale, length) => {
             const type = getType(length);
-            return getEras(locale, type).join('|');
+            return valuesRegExp(getEras(locale, type));
         },
         input: (locale, value, length) => {
             const type = getType(length);
@@ -91,26 +91,28 @@ export default {
     // quarter
     Q: {
         key: 'quarter',
+        supportsLength: (length) => length !== 3 && length !== 4,
         regex: (locale) => numberRegExp(locale),
         input: (locale, value) => parseNumber(locale, value),
         output: (datetime, length) =>
             formatNumber(
                 datetime.getLocale(),
                 datetime.getQuarter(),
-                length,
+                length < 3 ? length : 0,
             ),
     },
 
     // quarter (standalone)
     q: {
         key: 'quarter',
+        supportsLength: (length) => length !== 3 && length !== 4,
         regex: (locale) => numberRegExp(locale),
         input: (locale, value) => parseNumber(locale, value),
         output: (datetime, length) =>
             formatNumber(
                 datetime.getLocale(),
                 datetime.getQuarter(),
-                length,
+                length < 3 ? length : 0,
             ),
     },
 
@@ -119,25 +121,26 @@ export default {
     // month
     M: {
         key: 'month',
+        supportsLength: (length, parsing) => !parsing || length !== 5,
         regex: (locale, length) => {
             switch (length) {
                 case 5:
                 case 4:
-                case 3:
+                case 3: {
                     const type = getType(length);
-                    return getMonths(locale, type, false).join('|');
+                    return valuesRegExp(getMonths(locale, type, false));
+                }
                 default:
                     return numberRegExp(locale);
             }
         },
         input: (locale, value, length) => {
             switch (length) {
-                case 5:
-                    return null;
                 case 4:
-                case 3:
+                case 3: {
                     const type = getType(length);
                     return parseMonth(locale, value, type, false);
+                }
                 default:
                     return parseNumber(locale, value);
             }
@@ -148,9 +151,10 @@ export default {
             switch (length) {
                 case 5:
                 case 4:
-                case 3:
+                case 3: {
                     const type = getType(length);
                     return formatMonth(locale, month, type, false);
+                }
                 default:
                     return formatNumber(locale, month, length);
             }
@@ -160,25 +164,26 @@ export default {
     // month (standalone)
     L: {
         key: 'month',
+        supportsLength: (length, parsing) => !parsing || length !== 5,
         regex: (locale, length) => {
             switch (length) {
                 case 5:
                 case 4:
-                case 3:
+                case 3: {
                     const type = getType(length);
-                    return getMonths(locale, type).join('|');
+                    return valuesRegExp(getMonths(locale, type));
+                }
                 default:
                     return numberRegExp(locale);
             }
         },
         input: (locale, value, length) => {
             switch (length) {
-                case 5:
-                    return null;
                 case 4:
-                case 3:
+                case 3: {
                     const type = getType(length);
                     return parseMonth(locale, value, type);
+                }
                 default:
                     return parseNumber(locale, value);
             }
@@ -189,9 +194,10 @@ export default {
             switch (length) {
                 case 5:
                 case 4:
-                case 3:
+                case 3: {
                     const type = getType(length);
                     return formatMonth(locale, month, type);
+                }
                 default:
                     return formatNumber(locale, month, length);
             }
@@ -218,10 +224,11 @@ export default {
         key: 'weekOfMonth',
         regex: (locale) => numberRegExp(locale),
         input: (locale, value) => parseNumber(locale, value),
-        output: (datetime) =>
+        output: (datetime, length) =>
             formatNumber(
                 datetime.getLocale(),
                 datetime.getWeekOfMonth(),
+                length,
             ),
     },
 
@@ -258,25 +265,24 @@ export default {
         key: 'weekDayInMonth',
         regex: (locale) => numberRegExp(locale),
         input: (locale, value) => parseNumber(locale, value),
-        output: (datetime) =>
+        output: (datetime, length) =>
             formatNumber(
                 datetime.getLocale(),
                 datetime.getWeekDayInMonth(),
+                length,
             ),
     },
 
     // week day name
     E: {
         key: 'weekDay',
+        supportsLength: (length, parsing) =>
+            length !== 6 && (!parsing || length !== 5),
         regex: (locale, length) => {
             const type = getType(length);
-            return getDays(locale, type, false).join('|');
+            return valuesRegExp(getDays(locale, type, false));
         },
         input: (locale, value, length) => {
-            if (length === 5) {
-                return null;
-            }
-
             const type = getType(length);
             return parseDay(locale, value, type, false);
         },
@@ -291,86 +297,64 @@ export default {
     // week day
     e: {
         key: 'weekDay',
-        maxLength: 5,
+        supportsLength: (length, parsing) =>
+            length !== 6 && (!parsing || length !== 5),
         regex: (locale, length) => {
-            switch (length) {
-                case 5:
-                case 4:
-                case 3:
-                    const type = getType(length);
-                    return getDays(locale, type, false).join('|');
-                default:
-                    return numberRegExp(locale);
+            if (length < 3) {
+                return numberRegExp(locale);
             }
+
+            const type = getType(length);
+            return valuesRegExp(getDays(locale, type, false));
         },
         input: (locale, value, length) => {
-            switch (length) {
-                case 5:
-                    return null;
-                case 4:
-                case 3:
-                    const type = getType(length);
-                    return parseDay(locale, value, type, false);
-                default:
-                    return parseNumber(locale, value);
+            if (length < 3) {
+                return parseNumber(locale, value);
             }
+
+            const type = getType(length);
+            return parseDay(locale, value, type, false);
         },
         output: (datetime, length) => {
             const locale = datetime.getLocale();
-            switch (length) {
-                case 5:
-                case 4:
-                case 3:
-                    const type = getType(length);
-                    const day = datetime.getDay();
-                    return formatDay(locale, day, type, false);
-                default:
-                    const weekDay = datetime.getWeekDay();
-                    return formatNumber(locale, weekDay, length);
+            if (length < 3) {
+                return formatNumber(locale, datetime.getWeekDay(), length);
             }
+
+            const type = getType(length);
+            return formatDay(locale, datetime.getDay(), type, false);
         },
     },
 
     // week day (standalone)
     c: {
         key: 'weekDay',
-        maxLength: 5,
+        supportsLength: (length, parsing) =>
+            length !== 6 && (!parsing || length !== 5),
         regex: (locale, length) => {
-            switch (length) {
-                case 5:
-                case 4:
-                case 3:
-                    const type = getType(length);
-                    return getDays(locale, type).join('|');
-                default:
-                    return numberRegExp(locale);
+            if (length < 3) {
+                return numberRegExp(locale);
             }
+
+            const type = getType(length);
+            return valuesRegExp(getDays(locale, type));
         },
         input: (locale, value, length) => {
-            switch (length) {
-                case 5:
-                    return null;
-                case 4:
-                case 3:
-                    const type = getType(length);
-                    return parseDay(locale, value, type);
-                default:
-                    return parseNumber(locale, value);
+            if (length < 3) {
+                return parseNumber(locale, value);
             }
+
+            const type = getType(length);
+            return parseDay(locale, value, type);
         },
         output: (datetime, length) => {
             const locale = datetime.getLocale();
-            switch (length) {
-                case 5:
-                case 4:
-                case 3:
-                    const type = getType(length);
-                    const day = datetime.getDay();
-                    return formatDay(locale, day, type);
-                default:
-                    const weekDay = datetime.getWeekDay();
-                    return formatNumber(locale, weekDay);
+            if (length < 3) {
+                return formatNumber(locale, datetime.getWeekDay());
             }
+
+            const type = getType(length);
+            return formatDay(locale, datetime.getDay(), type);
         },
     },
 
@@ -378,9 +362,10 @@ export default {
 
     a: {
         key: 'dayPeriod',
+        supportsLength: (length) => length <= 4,
         regex: (locale, length) => {
             const type = getType(length);
-            return getDayPeriods(locale, type).join('|');
+            return valuesRegExp(getDayPeriods(locale, type));
         },
         input: (locale, value, length) => {
             const type = getType(length);
@@ -487,25 +472,28 @@ export default {
     S: {
         key: 'milliseconds',
         regex: (locale) => numberRegExp(locale),
-        input: (_) => 0,
-        output: (datetime, length) =>
-            formatNumber(
-                datetime.getLocale(),
-                `${Math.floor(
-                    datetime.getMilliseconds() *
-                    1000,
-                )}`.padEnd(length, '0').slice(0, length),
+        input: (locale, value) =>
+            parseInt(
+                parseNumberString(locale, value)
+                    .padEnd(3, '0')
+                    .slice(0, 3),
+                10,
             ),
+        output: (datetime, length) => {
+            const milliseconds = `${datetime.getMilliseconds()}`.padStart(3, '0');
+            return formatNumber(
+                datetime.getLocale(),
+                milliseconds.padEnd(length, '0').slice(0, length),
+            );
+        },
     },
 
     /* TIMEZONE/OFFSET */
 
     z: {
+        supportsLength: (_, parsing) => !parsing,
         output: (datetime, length) => {
-            if (length === 5) {
-                length = 1;
-            }
-            const type = getType(length);
+            const type = getType(Math.min(length, 4));
             return datetime.timeZoneName(type);
         },
     },
@@ -513,14 +501,13 @@ export default {
     Z: {
         key: 'timeZone',
         regex: (_, length) => {
-            switch (length) {
-                case 5:
-                    return `[\\+\\-]\\d{2}\\:\\d{2}|Z`;
-                case 4:
-                    return `GMT[\\+\\-]\\d{2}\\:\\d{2}|GMT`;
-                default:
-                    return `[\\+\\-]\\d{4}`;
+            if (length === 5) {
+                return `[\\+\\-]\\d{2}\\:\\d{2}(?:\\:\\d{2})?|Z`;
             }
+
+            return length >= 4 ?
+                `GMT[\\+\\-]\\d{2}\\:\\d{2}|GMT` :
+                `[\\+\\-]\\d{4}`;
         },
         input: (_, value) => value,
         output: (datetime, length) => {
@@ -528,31 +515,27 @@ export default {
 
             let useColon = true;
             let prefix = '';
-            switch (length) {
-                case 5:
-                    if (!offset) {
-                        return 'Z';
-                    }
-                    break;
-                case 4:
-                    prefix = 'GMT';
-
-                    if (!offset) {
-                        return prefix;
-                    }
-
-                    break;
-                default:
-                    useColon = false;
-                    break;
+            if (length === 5) {
+                if (!offset) {
+                    return 'Z';
+                }
+            } else if (length >= 4) {
+                prefix = 'GMT';
+
+                if (!offset) {
+                    return prefix;
+                }
+            } else {
+                useColon = false;
             }
 
-            return prefix + formatOffset(offset, useColon);
+            return prefix + formatOffset(offset, useColon, false, length === 5);
         },
     },
 
     O: {
         key: 'timeZone',
+        supportsLength: (length) => length === 1 || length === 4,
         regex: (_, length) => {
             switch (length) {
                 case 4:
@@ -584,19 +567,23 @@ export default {
 
     V: {
         key: 'timeZone',
-        regex: (_) => '([a-zA-Z_\/]+)',
+        supportsLength: (length) => length === 2,
+        regex: (_) => '([A-Za-z0-9_.+\\-/]+)',
         input: (_, value) => value,
         output: (datetime) => datetime.getTimeZone(),
     },
 
     X: {
         key: 'timeZone',
+        supportsLength: (length) => length <= 5,
         regex: (_, length) => {
             switch (length) {
                 case 5:
+                    return `[\\+\\-]\\d{2}\\:\\d{2}(?:\\:\\d{2})?|Z`;
+                case 4:
+                    return `[\\+\\-]\\d{4}(?:\\d{2})?|Z`;
                 case 3:
                     return `[\\+\\-]\\d{2}\\:\\d{2}|Z`;
-                case 4:
                 case 2:
                     return `[\\+\\-]\\d{4}|Z`;
                 default:
@@ -622,18 +609,21 @@ export default {
                     break;
             }
 
-            return formatOffset(offset, useColon, length === 1);
+            return formatOffset(offset, useColon, length === 1, length >= 4);
         },
     },
 
     x: {
         key: 'timeZone',
+        supportsLength: (length) => length <= 5,
         regex: (_, length) => {
             switch (length) {
                 case 5:
+                    return `[\\+\\-]\\d{2}\\:\\d{2}(?:\\:\\d{2})?`;
+                case 4:
+                    return `[\\+\\-]\\d{4}(?:\\d{2})?`;
                 case 3:
                     return `[\\+\\-]\\d{2}\\:\\d{2}`;
-                case 4:
                 case 2:
                     return `[\\+\\-]\\d{4}`;
                 default:
@@ -653,7 +643,7 @@ export default {
                     break;
             }
 
-            return formatOffset(datetime.getTimeZoneOffset(), useColon, length === 1);
+            return formatOffset(datetime.getTimeZoneOffset(), useColon, length === 1, length >= 4);
         },
     },
 

package/src/formatter/utility.js

@@ -1,8 +1,19 @@
-import { minDaysInFirstWeek, weekStart } from './locales.js';
-import { getData } from './../factory.js';
+import { getWeekInfo } from './locale.js';
+import { numberRegExp } from './values.js';
 
 /**
- * Get the formatting type from the component token length.
+ * Decodes a quoted ICU format literal.
+ * @param {string} literal The literal to decode.
+ * @return {string} The decoded literal.
+ */
+export function decodeLiteral(literal) {
+    return literal === `''` ?
+        `'` :
+        literal.slice(1, -1).replace(/''/g, `'`);
+};
+
+/**
+ * Gets the formatting type from the component token length.
  * @param {number} length The component token length.
  * @return {string} The formatting type.
  */
@@ -18,79 +29,42 @@ export function getType(length) {
 };
 
 /**
- * Get the minimum days.
- * @param {string} locale The locale.
- * @return {number} The minimum days.
+ * Gets the parsing RegExp data for a format token.
+ * @param {string} source The token RegExp.
+ * @param {string|null} nextSource The next token RegExp.
+ * @param {number} length The token length.
+ * @param {string} locale The parsing locale.
+ * @param {boolean} previousNumeric Whether the previous token was an adjacent numeric token.
+ * @return {{numeric: boolean, source: string}} The token RegExp data.
  */
-export function minimumDays(locale) {
-    return getData(
-        `minimumDays.${locale}`,
-        (_) => {
-            let minDays = 1;
-            const localeTest = locale.toLowerCase().split('-');
-            while (minDays === 1 && localeTest.length) {
-                for (const days in minDaysInFirstWeek) {
-                    if (!{}.hasOwnProperty.call(minDaysInFirstWeek, days)) {
-                        continue;
-                    }
-
-                    const locales = minDaysInFirstWeek[days];
-
-                    if (locales.includes(localeTest.join('-'))) {
-                        minDays = parseInt(days);
-                        break;
-                    }
-                }
+export function getTokenRegExp(source, nextSource, length, locale, previousNumeric) {
+    const numberSource = numberRegExp(locale);
+    let numeric = true;
 
-                localeTest.pop();
-            }
+    if (source !== numberSource) {
+        numeric = false;
+    } else if (previousNumeric || nextSource === numberSource) {
+        source = numberRegExp(locale, length);
+    }
 
-            return minDays;
-        },
-    );
+    return { numeric, source };
 };
 
 /**
- * Get the week start offset for a locale.
- * @param {string} [locale] The locale to load.
- * @return {number} The week start offset.
+ * Gets the locale's minimum days in the first week of the year.
+ * @param {string} locale The locale.
+ * @return {number} The minimum day count.
  */
-function weekStartOffset(locale) {
-    return getData(
-        `weekStartOffset.${locale}`,
-        (_) => {
-            let weekStarted;
-            const localeTest = locale.toLowerCase().split('-');
-            while (!weekStarted && localeTest.length) {
-                for (const start in weekStart) {
-                    if (!{}.hasOwnProperty.call(weekStart, start)) {
-                        continue;
-                    }
-
-                    const locales = weekStart[start];
-
-                    if (locales.includes(localeTest.join('-'))) {
-                        weekStarted = parseInt(start);
-                        break;
-                    }
-                }
-
-                localeTest.pop();
-            }
-
-            return weekStarted ?
-                weekStarted - 2 :
-                0;
-        },
-    );
+export function minimumDays(locale) {
+    return getWeekInfo(locale).minimalDays;
 };
 
 /**
- * Convert a day of the week to a local format.
+ * Converts a Sunday-based day-of-week value to the locale's week numbering.
  * @param {string} locale The locale.
- * @param {number} day The day of the week.
+ * @param {number} day The day of the week. (0 = Sunday, 6 = Saturday)
  * @return {number} The local day of the week.
  */
 export function weekDay(locale, day) {
-    return (7 + parseInt(day) - weekStartOffset(locale)) % 7 || 7;
+    return (7 + parseInt(day, 10) - (getWeekInfo(locale).firstDay % 7)) % 7 + 1;
 };