Compensate for Intl.DateTimeFormat implementations (like in Safari) that don't handle dateStyle and timeStyle options. Fix parsing of UTC offset using \u2212 minus sign. Add roundToMinutes option to parseTimeOffset(). Make sure Etc/GMTxx timezone names parse correctly.

Author: kshetline

.npmignore

@@ -13,3 +13,4 @@
 /webpack.config.cjs
 /make-remote-zone-data.ts
 *.tgz
+/test.html

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@tubular/time",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "Date/time, IANA timezones, calendar with settable Julian/Gregorian switchover",
   "browser": "dist/web/index.js",
   "browser-es5": "dist/web5/index.js",
@@ -58,8 +58,6 @@
     "eslint-plugin-standard": "^5.0.0",
     "esm": "^3.2.25",
     "mocha": "^8.2.1",
-    "moment": "^2.29.1",
-    "moment-timezone": "^0.5.32",
     "nyc": "^15.1.0",
     "rimraf": "^3.0.2",
     "ts-node": "^9.1.1",

package.json

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { parseISODateTime } from './common';
+import { parseISODateTime, parseTimeOffset } from './common';
 
 describe('Common', () => {
   it('should parse ISO date/time strings.', () => {
@@ -22,5 +22,12 @@ describe('Common', () => {
     expect(parseISODateTime('2020-W01-1')).to.include({ yw: 2020, w: 1, dw: 1, hrs: 0, min: 0, sec: 0 });
     expect(parseISODateTime('2020001')).to.include({ y: 2020, dy: 1, hrs: 0, min: 0, sec: 0 });
     expect(parseISODateTime('2020-001')).to.include({ y: 2020, dy: 1, hrs: 0, min: 0, sec: 0 });
+
+    expect(parseTimeOffset('+0100')).to.equal(3600);
+    expect(parseTimeOffset('+010023')).to.equal(3623);
+    expect(parseTimeOffset('-02')).to.equal(-7200);
+    expect(parseTimeOffset('-02:00')).to.equal(-7200);
+    expect(parseTimeOffset('-02:00:25', true)).to.equal(-7200);
+    expect(parseTimeOffset('-02:00:35', true)).to.equal(-7260);
   });
 });

src/common.spec.ts

@@ -252,7 +252,7 @@ export function parseISODateTime(date: string, allowLeapSecond = false): DateAnd
   return syncDateAndTime(time);
 }
 
-export function parseTimeOffset(offset: string): number {
+export function parseTimeOffset(offset: string, roundToMinutes = false): number {
   let sign = 1;
 
   if (offset.startsWith('-')) {
@@ -267,8 +267,14 @@ export function parseTimeOffset(offset: string): number {
     offset.match(/../g);
   let offsetSeconds = 60 * (60 * Number(parts[0]) + Number(parts[1] ?? 0));
 
-  if (parts[2])
-    offsetSeconds += Number(parts[2]);
+  if (parts[2]) {
+    const seconds = Number(parts[2]);
+
+    if (roundToMinutes)
+      offsetSeconds += (seconds < 30 ? 0 : 60);
+    else
+      offsetSeconds += seconds;
+  }
 
   return sign * offsetSeconds;
 }

src/common.ts

@@ -196,7 +196,7 @@ export class DateTime extends Calendar {
       if (initialTime!.includes('₂'))
         occurrence = 2;
 
-      initialTime = initialTime!.replace(/[­‐‑‒–—]/g, '-').replace(/\s+/g, ' ').replace(/₂/g, '').trim();
+      initialTime = initialTime!.replace(/[\u00AD\u2010-\u2014\u2212]/g, '-').replace(/\s+/g, ' ').replace(/₂/g, '').trim();
       let $ = /^\/Date\((\d+)([-+]\d\d\d\d)?\)\/$/i.exec(initialTime);
 
       if ($) {
@@ -208,14 +208,14 @@ export class DateTime extends Calendar {
       const saveTime = initialTime;
       let zone: string;
 
-      $ = /(Z|\b[_/a-z]+)$/i.exec(initialTime);
+      $ = /(Z|\bEtc\/GMT(?:0|[-+]\d{1,2})|\b[_/a-z]+)$/i.exec(initialTime);
 
       if ($) {
         zone = $[1];
 
         initialTime = initialTime.slice(0, -zone.length).trim() || null;
 
-        if (/^(Z|UT|UTC|GMT)$/i.test(zone))
+        if (/^(Z|UTC?|GMT)$/i.test(zone))
           zone = 'UT';
 
         parseZone = Timezone.has(zone) ? Timezone.from(zone) : null;

src/date-time.ts

@@ -174,7 +174,9 @@ describe('FormatParse', () => {
       .to.equal(Date.UTC(2022, 6, 7, 16, 5, 0) - 3 * 3_600_000);
     expect(parse('Jul 7, 2022 04:05 PM UT+0300', 'MMM D, y n hh:mm A z').utcTimeMillis)
       .to.equal(Date.UTC(2022, 6, 7, 16, 5, 0) - 3 * 3_600_000);
-    expect(parse('Jul 7, 2022 04:05 PM GMT+0300', 'MMM D, y n hh:mm A z').utcTimeMillis)
+    expect(parse('Jul 7, 2022 04:05 PM GMT-0300', 'MMM D, y n hh:mm A z').utcTimeMillis)
+      .to.equal(Date.UTC(2022, 6, 7, 16, 5, 0) + 3 * 3_600_000);
+    expect(parse('Jul 7, 2022 04:05 PM Etc/GMT+3', 'MMM D, y n hh:mm A z').utcTimeMillis)
       .to.equal(Date.UTC(2022, 6, 7, 16, 5, 0) + 3 * 3_600_000);
   });
 });

src/format-parse.spec.ts

@@ -3,8 +3,12 @@ import { DateTime } from './date-time';
 import { abs, floor, mod } from '@tubular/math';
 import { ILocale } from './i-locale';
 import { flatten, isArray, isEqual, isNumber, isString, last, toNumber } from '@tubular/util';
-import { getMeridiems, getMinDaysInWeek, getOrdinals, getStartOfWeek, getWeekend, hasIntlDateTime, normalizeLocale } from './locale-data';
+import {
+  checkDtfOptions, getMeridiems, getMinDaysInWeek, getOrdinals, getStartOfWeek, getWeekend,
+  hasIntlDateTime, normalizeLocale
+} from './locale-data';
 import { Timezone } from './timezone';
+import DateTimeFormat = Intl.DateTimeFormat;
 import DateTimeFormatOptions = Intl.DateTimeFormatOptions;
 
 const shortOpts = { Y: 'year', M: 'month', D: 'day', w: 'weekday', h: 'hour', m: 'minute', s: 'second', z: 'timeZoneName',
@@ -118,7 +122,7 @@ function isCased(s: string): boolean {
 }
 
 function timeMatch(dt: DateTime, locale: ILocale): boolean {
-  const format = locale.dateTimeFormats.check as Intl.DateTimeFormat;
+  const format = locale.dateTimeFormats.check as DateTimeFormat;
 
   if (!format)
     return false;
@@ -384,21 +388,21 @@ export function format(dt: DateTime, fmt: string, localeOverride?: string | stri
           break;
         }
         else if (hasIntlDateTime) {
-          result.push(Intl.DateTimeFormat().resolvedOptions().timeZone);
+          result.push(DateTimeFormat().resolvedOptions().timeZone);
           break;
         }
 
       // eslint-disable-next-line no-fallthrough
       case 'zzz':  // As long zone name (e.g. "Pacific Daylight Time"), if possible
-        if (hasIntlDateTime && locale.dateTimeFormats.Z instanceof Intl.DateTimeFormat) {
+        if (hasIntlDateTime && locale.dateTimeFormats.Z instanceof DateTimeFormat) {
           result.push(getDatePart(locale.dateTimeFormats.Z, dt.utcTimeMillis, 'timeZoneName'));
           break;
         }
 
       // eslint-disable-next-line no-fallthrough
       case 'zz':  // As zone acronym (e.g. EST, PDT, AEST), if possible
       case 'z':
-        if (hasIntlDateTime && locale.dateTimeFormats.z instanceof Intl.DateTimeFormat) {
+        if (hasIntlDateTime && locale.dateTimeFormats.z instanceof DateTimeFormat) {
           result.push(getDatePart(locale.dateTimeFormats.z, dt.utcTimeMillis, 'timeZoneName'));
           break;
         }
@@ -435,10 +439,10 @@ export function format(dt: DateTime, fmt: string, localeOverride?: string | stri
           result.push(locale.eras[(year < 1 ? 0 : 1) + (field.length === 4 ? 2 : 0)]);
         else if (field.startsWith('I')) {
           if (hasIntlDateTime) {
-            let intlFormat = locale.dateTimeFormats[field] as Intl.DateTimeFormat;
+            let intlFormat = locale.dateTimeFormats[field] as DateTimeFormat;
 
             if (!intlFormat) {
-              const options: Intl.DateTimeFormatOptions = { calendar: 'gregory' };
+              const options: DateTimeFormatOptions = { calendar: 'gregory' };
               const zone = convertDigits(dt.timezone.zoneName);
               let $: RegExpExecArray;
 
@@ -458,12 +462,12 @@ export function format(dt: DateTime, fmt: string, localeOverride?: string | stri
                 options.timeStyle = styleOptValues[field.charAt(2)];
 
               try {
-                locale.dateTimeFormats[field] = intlFormat = new Intl.DateTimeFormat(localeNames, options);
+                locale.dateTimeFormats[field] = intlFormat = new DateTimeFormat(localeNames, checkDtfOptions(options));
               }
               catch {
                 console.warn('Timezone "%s" not recognized', options.timeZone);
                 delete options.timeZone;
-                locale.dateTimeFormats[field] = intlFormat = new Intl.DateTimeFormat(localeNames, options);
+                locale.dateTimeFormats[field] = intlFormat = new DateTimeFormat(localeNames, options);
               }
             }
 
@@ -512,8 +516,8 @@ export function format(dt: DateTime, fmt: string, localeOverride?: string | stri
   return result.join('');
 }
 
-function quickFormat(localeNames: string | string[], timezone: string, opts: any): Intl.DateTimeFormat {
-  const options: Intl.DateTimeFormatOptions = { calendar: 'gregory' };
+function quickFormat(localeNames: string | string[], timezone: string, opts: any): DateTimeFormat {
+  const options: DateTimeFormatOptions = { calendar: 'gregory' };
   let $: RegExpExecArray;
 
   localeNames = normalizeLocale(localeNames);
@@ -535,7 +539,7 @@ function quickFormat(localeNames: string | string[], timezone: string, opts: any
     options[key] = value;
   });
 
-  return new Intl.DateTimeFormat(localeNames, options);
+  return new DateTimeFormat(localeNames, checkDtfOptions(options));
 }
 
 // Find the shortest case-insensitive version of each string in the array that doesn't match
@@ -568,15 +572,15 @@ function getLocaleInfo(localeNames: string | string[]): ILocale {
   if (locale && Object.keys(locale).length > 0)
     return locale;
 
-  const fmt = (opts: any): Intl.DateTimeFormat => quickFormat(localeNames, 'UTC', opts);
+  const fmt = (opts: any): DateTimeFormat => quickFormat(localeNames, 'UTC', opts);
 
   locale.name = isArray(localeNames) ? localeNames.join(',') : localeNames;
 
   if (hasIntlDateTime) {
     locale.months = [];
     locale.monthsShort = [];
     const narrow: string[] = [];
-    let format: Intl.DateTimeFormat;
+    let format: DateTimeFormat;
 
     for (let month = 1; month <= 12; ++month) {
       const date = Date.UTC(2021, month - 1, 1);
@@ -671,7 +675,7 @@ function getLocaleInfo(localeNames: string | string[]): ILocale {
 }
 
 function generatePredefinedFormats(locale: ILocale, timezone: string): void {
-  const fmt = (opts: any): Intl.DateTimeFormat => quickFormat(locale.name, timezone, opts);
+  const fmt = (opts: any): DateTimeFormat => quickFormat(locale.name, timezone, opts);
 
   locale.cachedTimezone = timezone;
   locale.dateTimeFormats = {};
@@ -694,7 +698,7 @@ function generatePredefinedFormats(locale: ILocale, timezone: string): void {
     Object.keys(locale.dateTimeFormats).forEach(key => {
       if (/^L/i.test(key))
         locale.dateTimeFormats['_' + key] = analyzeFormat(locale.name.split(','),
-          locale.dateTimeFormats[key] as Intl.DateTimeFormat);
+          locale.dateTimeFormats[key] as DateTimeFormat);
     });
   }
   else {
@@ -720,9 +724,9 @@ function isLocale(locale: string | string[], matcher: string): boolean {
     return false;
 }
 
-export function analyzeFormat(locale: string | string[], formatter: Intl.DateTimeFormat): string;
+export function analyzeFormat(locale: string | string[], formatter: DateTimeFormat): string;
 export function analyzeFormat(locale: string | string[], dateStyle: string, timeStyle?: string): string;
-export function analyzeFormat(locale: string | string[], dateStyleOrFormatter: string | Intl.DateTimeFormat,
+export function analyzeFormat(locale: string | string[], dateStyleOrFormatter: string | DateTimeFormat,
                               timeStyle?: string): string {
   const options: DateTimeFormatOptions = { timeZone: 'UTC', calendar: 'gregory' };
   let dateStyle: string;
@@ -745,7 +749,7 @@ export function analyzeFormat(locale: string | string[], dateStyleOrFormatter: s
   }
 
   const sampleDate = Date.UTC(2233, 3 /* 4 */, 5, 6, 7, 8);
-  const format = new Intl.DateTimeFormat(locale, options);
+  const format = new DateTimeFormat(locale, checkDtfOptions(options));
   const parts = format.formatToParts(sampleDate);
   const dateLong = (dateStyle === 'full' || dateStyle === 'long');
   const monthLong = (dateLong || (dateStyle === 'medium' && isLocale(locale, 'ne')));
@@ -921,7 +925,8 @@ export function parse(input: string, format: string, zone?: Timezone | string, l
   if (input.includes('₂'))
     occurrence = 2;
 
-  input = convertDigits(input.replace(/[­‐‑‒–—]/g, '-').replace(/\s+/g, ' ').trim()).replace(/[\u200F₂]/g, '');
+  input = convertDigits(input.replace(/[\u00AD\u2010-\u2014\u2212]/g, '-')
+    .replace(/\s+/g, ' ').trim()).replace(/[\u200F₂]/g, '');
   format = format.trim().replace(/\u200F/g, '');
   locales = !hasIntlDateTime ? 'en' : normalizeLocale(locales ?? DateTime.getDefaultLocale());
 
@@ -1167,10 +1172,10 @@ export function parse(input: string, format: string, zone?: Timezone | string, l
       case 'z':
         trimmed = false;
 
-        if (($ = /^(Z|[_/a-z]+)([^-+_/a-z]|$)/i.exec(input))) {
+        if (!/^UTC?[-+]/.test(input) && ($ = /^(Z|\bEtc\/GMT(?:0|[-+]\d{1,2})|[_/a-z]+)([^-+_/a-z]|$)/i.exec(input))) {
           let embeddedZone: string | Timezone = $[1];
 
-          if (/^(Z|UT|UTC|GMT)$/i.test(embeddedZone))
+          if (/^(Z|UTC?|GMT)$/i.test(embeddedZone))
             embeddedZone = 'UT';
 
           embeddedZone = Timezone.from(embeddedZone);
@@ -1194,8 +1199,8 @@ export function parse(input: string, format: string, zone?: Timezone | string, l
             trimmed = true;
           }
         }
-        else if (($ = /^(UTC|UT|GMT)?([-+]\d\d(?:\d{4}|:\d\d(:\d\d)?)?)/i.exec(input))) {
-          w.utcOffset = parseTimeOffset($[2]) * ($[1] === 'GMT' ? -1 : 1);
+        else if (($ = /^(UTC?|GMT)?([-+]\d\d(?:\d{4}|:\d\d(:\d\d)?)?)/i.exec(input))) {
+          w.utcOffset = parseTimeOffset($[2]);
           input = input.substr($[0].length).trimStart();
           trimmed = true;
         }

src/format-parse.ts

@@ -1,13 +1,56 @@
 import { isArray, isNumber, isString } from '@tubular/util';
+import DateTimeFormat = Intl.DateTimeFormat;
+import DateTimeFormatOptions = Intl.DateTimeFormatOptions;
 
 let _hasIntl = false;
+let _hasDateTimeStyle = true;
 
 try {
   _hasIntl = typeof Intl !== 'undefined' && !!Intl?.DateTimeFormat;
+
+  if (_hasIntl) {
+    const full = new DateTimeFormat('en-us', { dateStyle: 'full' }).format(0);
+    const short = new DateTimeFormat('en-us', { dateStyle: 'short' }).format(0);
+
+    _hasDateTimeStyle = full !== short;
+
+    if (!_hasDateTimeStyle)
+      console.warn('Intl.DateTimeFormatOptions dateStyle and timeStyle not available');
+  }
+  else
+    console.warn('Intl.DateTimeFormat not available');
 }
 catch {}
 
 export const hasIntlDateTime = _hasIntl;
+export const hasDateTimeStyle = _hasDateTimeStyle;
+
+const backupDateFormats: Record<string, DateTimeFormatOptions> = {
+  full: { year: 'numeric', month: 'long', day: 'numeric', weekday: 'long' },
+  long: { year: 'numeric', month: 'long', day: 'numeric' },
+  medium: { year: 'numeric', month: 'short', day: 'numeric' },
+  short: { year: '2-digit', month: 'numeric', day: 'numeric' }
+};
+const backupTimeFormats: Record<string, DateTimeFormatOptions> = {
+  full: { hour: 'numeric', minute: '2-digit', second: '2-digit', timeZoneName: 'long' },
+  long: { hour: 'numeric', minute: '2-digit', second: '2-digit', timeZoneName: 'short' },
+  medium: { hour: 'numeric', minute: '2-digit', second: '2-digit' },
+  short: { hour: 'numeric', minute: '2-digit' }
+};
+
+export function checkDtfOptions(options: DateTimeFormatOptions): DateTimeFormatOptions {
+  if (!hasDateTimeStyle && options.dateStyle) {
+    Object.assign(options, backupDateFormats[options.dateStyle]);
+    delete options.dateStyle;
+  }
+
+  if (!hasDateTimeStyle && options.timeStyle) {
+    Object.assign(options, backupTimeFormats[options.timeStyle]);
+    delete options.timeStyle;
+  }
+
+  return options;
+}
 
 export const localeList = [
   'af', 'ar', 'ar-dz', 'ar-kw', 'ar-ly', 'ar-ma', 'ar-sa', 'ar-tn', 'az', 'be', 'bg', 'bm', 'bn', 'bn-bd',

src/locale-data.ts

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Browser Check</title>
+  <script src="dist/web/index.js"></script>
+</head>
+<body>
+  <script>
+    const ttime = window.tbTime.ttime;
+    const now = ttime();
+    const styles = ['F', 'L', 'M', 'S', 'x'];
+
+    for (const locale of ['en', 'fr', 'de', 'es', 'it']) {
+      const nowL = now.toLocale(locale);
+
+      for (let i = 0; i < 5; ++i) {
+        for (let j = 0; j < 5 - +(i === 4); ++j) {
+          const format = 'I' + styles[i] + (styles[j] !== 'x' ? styles[j] : '');
+          const matchFormat = format.replace(/^Ix/, 'IS');
+          const formatted = nowL.format(format);
+          const parsed = ttime(i < 4 ? formatted : nowL.format(matchFormat), matchFormat, locale);
+          const matched = now.isSame(parsed, j === 4 ? 'day' : j < 4 ? 'minute' : 'second');
+          if (!matched)
+            console.warn('mismatch');
+
+          document.write('<code>' + format.padEnd(3) + '</code>: ' + formatted +
+              (matched ? ' <span style="color: green">✔</span>' : ' <span style="color: red">✘</span>') + '<br>\n');
+        }
+      }
+
+      document.write('<br><br>\n');
+    }
+  </script>
+</body>
+</html>