@formatjs/intl-datetimeformat 7.1.0 → 7.1.1

package/src/abstract/FormatDateTimePattern.js

@@ -105,7 +105,18 @@ export function FormatDateTimePattern(dtf, patternParts, x, _a) {
             var timeZone = internalSlots.timeZone || getDefaultTimeZone();
             var timeZoneData = timeZoneName[timeZone];
             if (timeZoneData && timeZoneData[f]) {
-                fv = timeZoneData[f][+tm.inDST];
+                var names = timeZoneData[f];
+                // GH #5114: If in DST and both standard/daylight names are the same,
+                // fall back to GMT offset format (matches native browser behavior).
+                // This handles locales where CLDR doesn't provide a daylight name.
+                // NOTE: This is a formatjs implementation detail - ECMA-402 doesn't
+                // explicitly specify behavior for missing DST names in locale data.
+                if (tm.inDST && names.length >= 2 && names[0] === names[1]) {
+                    fv = offsetToGmtString(gmtFormat, hourFormat, tm.timeZoneOffset, f);
+                }
+                else {
+                    fv = names[+tm.inDST];
+                }
             }
             else {
                 // Fallback to gmtFormat

package/src/abstract/ToLocalTime.js

@@ -1,11 +1,84 @@
 import { DateFromTime, HourFromTime, MinFromTime, MonthFromTime, SecFromTime, WeekDay, YearFromTime, invariant, msFromTime, } from '@formatjs/ecma402-abstract';
+// Cached regex patterns for performance
+var OFFSET_TIMEZONE_PREFIX_REGEX = /^[+-]/;
+var OFFSET_TIMEZONE_FORMAT_REGEX = /^([+-])(\d{2})(?::?(\d{2}))?(?::?(\d{2}))?(?:\.(\d{1,9}))?$/;
+/**
+ * IsTimeZoneOffsetString ( offsetString )
+ * https://tc39.es/ecma262/#sec-istimezoneoffsetstring
+ *
+ * Determines if a string is a UTC offset identifier.
+ *
+ * @param offsetString - The string to check
+ * @returns true if offsetString is a UTC offset format
+ */
+function IsTimeZoneOffsetString(offsetString) {
+    return OFFSET_TIMEZONE_PREFIX_REGEX.test(offsetString);
+}
+/**
+ * ParseTimeZoneOffsetString ( offsetString )
+ * https://tc39.es/ecma262/#sec-parsetimezoneoffsetstring
+ *
+ * Parses a UTC offset string and returns the offset in milliseconds.
+ * This is used to calculate the timezone offset for ToLocalTime.
+ *
+ * Supports formats: ±HH, ±HHMM, ±HH:MM, ±HH:MM:SS, ±HH:MM:SS.sss
+ *
+ * @param offsetString - The UTC offset string to parse (e.g., "+01:00")
+ * @returns The offset in milliseconds
+ */
+function ParseTimeZoneOffsetString(offsetString) {
+    // 1. Let parseResult be ParseText(offsetString, UTCOffset)
+    var match = OFFSET_TIMEZONE_FORMAT_REGEX.exec(offsetString);
+    // 2. Assert: parseResult is not a List of errors
+    if (!match) {
+        return 0;
+    }
+    // 3. Extract components from parseResult
+    var sign = match[1] === '+' ? 1 : -1;
+    var hours = parseInt(match[2], 10);
+    var minutes = match[3] ? parseInt(match[3], 10) : 0;
+    var seconds = match[4] ? parseInt(match[4], 10) : 0;
+    var fractionalStr = match[5] || '0';
+    // 4. Convert fractional seconds (nanoseconds) to milliseconds
+    // Pad to 9 digits and divide by 1000000
+    // Use manual padding for compatibility (padEnd is ES2017)
+    var paddedFractional = (fractionalStr + '000000000').slice(0, 9);
+    var fractional = parseInt(paddedFractional, 10) / 1000000;
+    // 5. Calculate total offset in milliseconds
+    // offset = sign × (hours × 3600000 + minutes × 60000 + seconds × 1000 + fractional)
+    var offsetMs = sign * (hours * 3600000 + minutes * 60000 + seconds * 1000 + fractional);
+    // 6. Return offset in milliseconds
+    return offsetMs;
+}
+/**
+ * GetNamedTimeZoneOffsetNanoseconds ( timeZone, t )
+ * Similar to abstract operation in ECMA-262, adapted for IANA timezone data.
+ * Extended to support UTC offset time zones per ECMA-402 PR #788.
+ *
+ * Returns the timezone offset in milliseconds (not nanoseconds for this impl)
+ * and DST flag for the given timezone at time t.
+ *
+ * @param t - Time value in milliseconds since epoch
+ * @param timeZone - The timezone identifier
+ * @param tzData - IANA timezone database
+ * @returns Tuple of [offset in milliseconds, inDST boolean]
+ */
 function getApplicableZoneData(t, timeZone, tzData) {
     var _a;
+    // 1. If IsTimeZoneOffsetString(timeZone) is true, then
+    //    a. Let offsetNs be ParseTimeZoneOffsetString(timeZone)
+    //    b. Return offsetNs (no DST for offset timezones)
+    if (IsTimeZoneOffsetString(timeZone)) {
+        var offsetMs = ParseTimeZoneOffsetString(timeZone);
+        return [offsetMs, false]; // UTC offset timezones never observe DST
+    }
+    // 2. Let timeZoneData be the IANA Time Zone Database entry for timeZone
     var zoneData = tzData[timeZone];
-    // We don't have data for this so just say it's UTC
+    // 3. If no data available, treat as UTC (0 offset, no DST)
     if (!zoneData) {
         return [0, false];
     }
+    // 4. Find the applicable transition for time t
     var i = 0;
     var offset = 0;
     var dst = false;
@@ -16,6 +89,7 @@ function getApplicableZoneData(t, timeZone, tzData) {
             break;
         }
     }
+    // 5. Return offset in milliseconds and DST flag
     return [offset * 1e3, dst];
 }
 /**

package/src/core.js

@@ -8,7 +8,7 @@ import { FormatDateTimeToParts } from './abstract/FormatDateTimeToParts.js';
 import { InitializeDateTimeFormat } from './abstract/InitializeDateTimeFormat.js';
 import { parseDateTimeSkeleton } from './abstract/skeleton.js';
 import { DATE_TIME_PROPS } from './abstract/utils.js';
-import links from './data/links.js';
+import links from './data/links.generated.js';
 import getInternalSlots from './get_internal_slots.js';
 import { unpack } from './packer.js';
 var UPPERCASED_LINKS = Object.keys(links).reduce(function (all, l) {