@checkdigit/time 4.0.0 → 5.0.0-PR.21-7813

package/src/date-fns/types.ts

@@ -1,9 +1,25 @@
-/* eslint-disable no-unused-vars */
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
 
-import type { Locale } from './locale/types';
+import type { constructFromSymbol } from './constants/index.ts';
+import { Locale } from './locale/types.ts';
 
-export type * from './locale/types';
-export type * from './fp/types';
+export type * from './locale/types.ts';
+
+/**
+ * The argument type.
+ */
+export type DateArg<DateType extends Date> = DateType | number | string;
+
+/**
+ * Date extension interface that allows to transfer extra properties from
+ * the reference date to the new date. It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+ * that accept a time zone as a constructor argument.
+ */
+export interface ConstructableDate extends Date {
+  [constructFromSymbol]: <DateType extends Date = Date>(value: DateArg<Date> & {}) => DateType;
+}
 
 /**
  * The generic date constructor. Replicates the Date constructor. Used to build
@@ -27,7 +43,7 @@ export interface GenericDateConstructor<DateType extends Date = Date> {
    *
    * @returns The date instance
    */
-  new (value: Date | number | string): DateType;
+  new (value: DateArg<Date> & {}): DateType;
 
   /**
    * The date constructor. Creates date with the passed date values (year,
@@ -83,24 +99,23 @@ export type DurationUnit = keyof Duration;
 /**
  * An object that combines two dates to represent the time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam StartDate - The start `Date` type.
+ * @typeParam EndDate - The end `Date` type.
  */
-export interface Interval<DateType extends Date = Date> {
+export interface Interval<
+  StartType extends DateArg<Date> = DateArg<Date>,
+  EndType extends DateArg<Date> = DateArg<Date>,
+> {
   /** The start of the interval. */
-  start: DateType | number | string;
+  start: StartType;
   /** The end of the interval. */
-  end: DateType | number | string;
+  end: EndType;
 }
 
 /**
  * A version of {@link Interval} that has both start and end resolved to Date.
  */
-export interface NormalizedInterval<DateType extends Date = Date> {
-  /** The start of the interval. */
-  start: DateType;
-  /** The end of the interval. */
-  end: DateType;
-}
+export type NormalizedInterval<DateType extends Date = Date> = Interval<DateType, DateType>;
 
 /**
  * The era. Can be either 0 (AD - Anno Domini) or 1 (BC - Before Christ).
@@ -301,3 +316,28 @@ export interface NearestToUnitOptions<Unit extends number> {
    * hours. */
   nearestTo?: Unit;
 }
+
+/**
+ * The context options. Used to build function options.
+ */
+export interface ContextOptions<DateType extends Date> {
+  /**
+   * The context to use in the function. It allows to normalize the arguments
+   * to a specific date instance, which is useful for extensions like [`TZDate`](https://github.com/date-fns/tz).
+   */
+  in?: ContextFn<DateType> | undefined;
+}
+
+/**
+  /**
+   * The context function type. It's used to normalize the input arguments to
+   * a specific date instance, which is useful for extensions like [`TZDate`](https://github.com/date-fns/tz).
+   */
+export type ContextFn<DateType extends Date> = (value: DateArg<Date> & {}) => DateType;
+
+/**
+ * Resolves passed type or array of types.
+ */
+export type MaybeArray<Type> = Type | Type[];
+
+/* eslint-enable */

package/src/date-fns/weeksToDays/index.ts

@@ -1,4 +1,8 @@
-import { daysInWeek } from '../constants/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { daysInWeek } from '../constants/index.ts';
 
 /**
  * @name weeksToDays
@@ -20,3 +24,5 @@ import { daysInWeek } from '../constants/index';
 export function weeksToDays(weeks: number): number {
   return Math.trunc(weeks * daysInWeek);
 }
+
+/* eslint-enable */

package/src/date-fns/yearsToDays/index.ts

@@ -1,4 +1,8 @@
-import { daysInYear } from '../constants/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { daysInYear } from '../constants/index.ts';
 
 /**
  * @name yearsToDays
@@ -20,3 +24,5 @@ import { daysInYear } from '../constants/index';
 export function yearsToDays(years: number): number {
   return Math.trunc(years * daysInYear);
 }
+
+/* eslint-enable */

package/src/date-fns/yearsToMonths/index.ts

@@ -1,4 +1,8 @@
-import { monthsInYear } from '../constants/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { monthsInYear } from '../constants/index.ts';
 
 /**
  * @name yearsToMonths
@@ -20,3 +24,5 @@ import { monthsInYear } from '../constants/index';
 export function yearsToMonths(years: number): number {
   return Math.trunc(years * monthsInYear);
 }
+
+/* eslint-enable */

package/src/date-fns/yearsToQuarters/index.ts

@@ -1,4 +1,8 @@
-import { quartersInYear } from '../constants/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { quartersInYear } from '../constants/index.ts';
 
 /**
  * @name yearsToQuarters
@@ -20,3 +24,5 @@ import { quartersInYear } from '../constants/index';
 export function yearsToQuarters(years: number): number {
   return Math.trunc(years * quartersInYear);
 }
+
+/* eslint-enable */

package/src/date-fns-tz/CHANGELOG.md

@@ -1,3 +1,85 @@
+### v3.2.0 (27 September 2024)
+
+- [DEPS] `date-fns@4.0.0` supported (#301)
+- [PERFORMANCE] Make testDateFormatted static to avoid re-initialising it on every call (#297) @hurali97
+- [ENHANCEMENT] Compatibility with `date-fns` `setDefaultOptions` (#286) @yangchristina
+- [DOCS] Fixed table of contents links (#284)
+
+### v3.1.3 (17 April 2024)
+
+- [BUGFIX] Make `getTimeZoneOffset`'s 2nd arg optional
+
+### v3.1.2 (16 April 2024)
+
+- [BUGFIX] Fix `formatInTimeZone` use of `timeZone` string (#280)
+
+### v3.1.1 (16 April 2024)
+
+- [BUGFIX] `getTimeZoneOffset`'s 2nd arg should be optional (#281)
+
+### v3.1.0 (15 April 2024)
+
+- [REFACTOR] Full rewrite in TypeScript (#278) Thank you, @brettwillis
+- [BREAKING CHANGE] `OptionsWithTZ` is now either `FormatOptionsWithTZ` or `ToDateOptionsWithTZ`, matching `date-fns`
+
+### v3.0.1 (10 April 2024)
+
+- [BUGFIX] Fix named export typings (#277)
+
+### v3.0.0 (6 April 2024)
+
+- [UPGRADE] Support `date-fns` v3 (#265) Thank you, @christopherklint97
+- [BUGFIX] Correct import of `date-fns@v3` format and use Babel Webpack loader for mjs files (#271)
+- [BREAKING CHANGE] `date-fns` v2 is no longer supported
+- [BREAKING CHANGE] Renamed `utcToZonedTime` to `toZonedTime` to make the name less confusing, just search & replace
+- [BREAKING CHANGE] Renamed `zonedTimeToUtc` to `fromZonedTime` to make the name less confusing, just search & replace
+- [BREAKING CHANGE] All functions are now exported using named exports, this requires changing direct
+  imports from `import formatInTimeZone from 'date-fns-tz/formatInTimeZone'` to
+  `import { formatInTimeZone } from 'date-fns-tz/formatInTimeZone'`
+- [BREAKING CHANGE] Functions now don’t check the number of passed arguments, delegating this task to type checkers
+  (This isn't fully implemented yet, but it should be the assumption moving forward, as it is in `date-fns`)
+- [BREAKING CHANGE] Arguments are not explicitly converted to the target types. Instead, they are passed as is,
+  delegating this task to type checkers (This isn't fully implemented yet, but it should be the assumption
+  moving forward, as it is in `date-fns`)
+- [BREAKING CHANGE] IE is no longer supported since `date-fns` no longer supports it
+- [BREAKING CHANGE] Removed `flow` support since `date-fns` also removed it
+
+### v2.0.1 (9 March 2024)
+
+- [DOCS] Fix incorrect output comment (#270)
+- [DEPS] Limit to date-fns 2.x (#262, #267)
+- [REFACTOR] `tzTokenizeDate`: Remove weird unneeded regex (#254)
+- [BUGFIX] Improving correctness of the `formatInTimeZone` close to the DST threshold (#247)
+- [ENHANCEMENT] Use hourCycle for browsers that support hour cycle formatting (#231)
+- [BUGFIX] Fix tzParseTimezone to parse 00:30 timezones properly (#229)
+
+### v2.0.0 (30 January 2023)
+
+- [BREAKING CHANGE] Optimize configuration for ESM exports (entry points for cjs / esm / typescript) (#212)
+
+**Upgrade guide:** Both CJS and ESM imports now use the default import paths. CJS will continue working unchanged;
+to fix ESM imports:
+
+Before:
+
+```js
+import { format } from 'date-fns-tz/esm';
+import utcToZonedTime from 'date-fns-tz/esm/utcToZonedTime';
+```
+
+After:
+
+```js
+import { format } from 'date-fns-tz';
+import utcToZonedTime from 'date-fns-tz/utcToZonedTime';
+```
+
+### v1.3.8 (30 January 2023)
+
+- [TESTS] Tests documenting `zonedTimeToUtc` daylight saving jumps (#220)
+- [TYPES] Update `format` types to match date-fns (#199)
+- [BUGFIX] Fixed `undefined` timezone error (#214)
+
 ### v1.3.7 (31 August 2022)
 
 - [BUGFIX] Fixed getting the time zone name in `partsTimeZone` out of `formatToParts` (#196)

package/src/date-fns-tz/_lib/getTimezoneOffsetInMilliseconds/index.ts

@@ -0,0 +1,32 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+/**
+ * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+ * They usually appear for dates that denote time before the timezones were introduced
+ * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+ * and GMT+01:00:00 after that date)
+ *
+ * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+ * which would lead to incorrect calculations.
+ *
+ * This function returns the timezone offset in milliseconds that takes seconds in account.
+ */
+export function getTimezoneOffsetInMilliseconds(date: Date): number {
+  const utcDate = new Date(
+    Date.UTC(
+      date.getFullYear(),
+      date.getMonth(),
+      date.getDate(),
+      date.getHours(),
+      date.getMinutes(),
+      date.getSeconds(),
+      date.getMilliseconds(),
+    ),
+  );
+  utcDate.setUTCFullYear(date.getFullYear());
+  return +date - +utcDate;
+}
+
+/* eslint-enable */

package/src/date-fns-tz/_lib/newDateUTC/index.ts

@@ -1,3 +1,7 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
 /**
  * Use instead of `new Date(Date.UTC(...))` to support years below 100 which doesn't work
  * otherwise due to the nature of the
@@ -5,7 +9,7 @@
  *
  * For `Date.UTC(...)`, use `newDateUTC(...).getTime()`.
  */
-export default function newDateUTC(
+export function newDateUTC(
   fullYear: number,
   month: number,
   day: number,
@@ -13,9 +17,11 @@ export default function newDateUTC(
   minute: number,
   second: number,
   millisecond: number,
-) {
+): Date {
   const utcDate = new Date(0);
   utcDate.setUTCFullYear(fullYear, month, day);
   utcDate.setUTCHours(hour, minute, second, millisecond);
   return utcDate;
 }
+
+/* eslint-enable */

package/src/date-fns-tz/_lib/tzIntlTimeZoneName/index.ts

@@ -1,43 +1,53 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getDefaultOptions, type Locale } from '../../../date-fns/index.ts';
+import type { FormatOptionsWithTZ } from '../../index.ts';
+
 /**
  * Returns the formatted time zone name of the provided `timeZone` or the current
  * system time zone if omitted, accounting for DST according to the UTC value of
  * the date.
  */
-import type { Locale } from '../../../date-fns/locale/types';
-
-export default function tzIntlTimeZoneName(
-  length: 'short' | 'long' | 'shortOffset' | 'longOffset' | 'shortGeneric' | 'longGeneric',
+export function tzIntlTimeZoneName(
+  length: Intl.DateTimeFormatOptions['timeZoneName'],
   date: Date,
-  options: { timeZone: string; locale?: Locale },
-) {
-  const dtf = getDTF(length, options.timeZone, options.locale);
-  return partsTimeZone(dtf, date);
+  options: FormatOptionsWithTZ,
+): string | undefined {
+  const defaultOptions = getDefaultOptions();
+  const dtf = getDTF(length, options.timeZone, options.locale ?? defaultOptions.locale);
+  return 'formatToParts' in dtf ? partsTimeZone(dtf, date) : hackyTimeZone(dtf, date);
 }
 
-function partsTimeZone(dtf: Intl.DateTimeFormat, date: Date) {
+function partsTimeZone(dtf: Intl.DateTimeFormat, date: Date): string | undefined {
   const formatted = dtf.formatToParts(date);
+
   for (let i = formatted.length - 1; i >= 0; --i) {
-    if (formatted[i]?.type === 'timeZoneName') {
-      return formatted[i]?.value;
+    if (formatted[i].type === 'timeZoneName') {
+      return formatted[i].value;
     }
   }
   return undefined;
 }
 
+function hackyTimeZone(dtf: Intl.DateTimeFormat, date: Date) {
+  const formatted = dtf.format(date).replace(/\u200E/g, '');
+  const tzNameMatch = / [\w-+ ]+$/.exec(formatted);
+  return tzNameMatch ? tzNameMatch[0].substr(1) : '';
+}
+
 // If a locale has been provided `en-US` is used as a fallback in case it is an
 // invalid locale, otherwise the locale is left undefined to use the system locale.
 function getDTF(
-  length: 'short' | 'long' | 'shortOffset' | 'longOffset' | 'shortGeneric' | 'longGeneric',
-  timeZone: string,
-  locale?: Locale,
-): Intl.DateTimeFormat {
-  if (locale && !locale.code) {
-    throw new Error(
-      "date-fns-tz error: Please set a language code on the locale object imported from date-fns, e.g. `locale.code = 'en-US'`",
-    );
-  }
+  length: Intl.DateTimeFormatOptions['timeZoneName'],
+  timeZone: string | undefined,
+  locale: Pick<Locale, 'code'> | undefined,
+) {
   return new Intl.DateTimeFormat(locale ? [locale.code, 'en-US'] : undefined, {
     timeZone: timeZone,
     timeZoneName: length,
   });
 }
+
+/* eslint-enable */

package/src/date-fns-tz/_lib/tzParseTimezone/index.ts

@@ -1,5 +1,9 @@
-import tzTokenizeDate from '../tzTokenizeDate';
-import newDateUTC from '../newDateUTC';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { tzTokenizeDate } from '../tzTokenizeDate/index.ts';
+import { newDateUTC } from '../newDateUTC/index.ts';
 
 const MILLISECONDS_IN_HOUR = 3600000;
 const MILLISECONDS_IN_MINUTE = 60000;
@@ -8,31 +12,33 @@ const patterns = {
   timezone: /([Z+-].*)$/,
   timezoneZ: /^(Z)$/,
   timezoneHH: /^([+-]\d{2})$/,
-  timezoneHHMM: /^([+-]\d{2}):?(\d{2})$/,
+  timezoneHHMM: /^([+-])(\d{2}):?(\d{2})$/,
 };
 
-// Parse various time zone offset formats to an offset in milliseconds
-export default function tzParseTimezone(timezoneString: string, date?: Date, isUtcDate?: boolean) {
-  let token: RegExpExecArray | null;
-  let absoluteOffset;
-
+// Parse constious time zone offset formats to an offset in milliseconds
+export function tzParseTimezone(
+  timezoneString: string | undefined,
+  date: Date | number | undefined,
+  isUtcDate?: boolean,
+): number {
   // Empty string
-  if (timezoneString === '') {
+  if (!timezoneString) {
     return 0;
   }
 
   // Z
-  token = patterns.timezoneZ.exec(timezoneString);
+  let token = patterns.timezoneZ.exec(timezoneString);
   if (token) {
     return 0;
   }
 
-  let hours;
+  let hours: number;
+  let absoluteOffset: number;
 
   // ±hh
   token = patterns.timezoneHH.exec(timezoneString);
   if (token) {
-    hours = parseInt(token[1] as string, 10);
+    hours = parseInt(token[1], 10);
 
     if (!validateTimezone(hours)) {
       return NaN;
@@ -44,25 +50,25 @@ export default function tzParseTimezone(timezoneString: string, date?: Date, isU
   // ±hh:mm or ±hhmm
   token = patterns.timezoneHHMM.exec(timezoneString);
   if (token) {
-    hours = parseInt(token[1] as string, 10);
-    let minutes = parseInt(token[2] as string, 10);
+    hours = parseInt(token[2], 10);
+    const minutes = parseInt(token[3], 10);
 
     if (!validateTimezone(hours, minutes)) {
       return NaN;
     }
 
     absoluteOffset = Math.abs(hours) * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE;
-    return hours > 0 ? -absoluteOffset : absoluteOffset;
+    return token[1] === '+' ? -absoluteOffset : absoluteOffset;
   }
 
   // IANA time zone
   if (isValidTimezoneIANAString(timezoneString)) {
     date = new Date(date || Date.now());
-    let utcDate = isUtcDate ? date : toUtcDate(date);
+    const utcDate = isUtcDate ? date : toUtcDate(date);
 
-    let offset = calcOffset(utcDate, timezoneString);
+    const offset = calcOffset(utcDate, timezoneString);
 
-    let fixedOffset = isUtcDate ? offset : fixOffset(date, offset, timezoneString);
+    const fixedOffset = isUtcDate ? offset : fixOffset(date, offset, timezoneString);
 
     return -fixedOffset;
   }
@@ -83,33 +89,25 @@ function toUtcDate(date: Date) {
 }
 
 function calcOffset(date: Date, timezoneString: string) {
-  let tokens = tzTokenizeDate(date, timezoneString);
+  const tokens = tzTokenizeDate(date, timezoneString);
 
   // ms dropped because it's not provided by tzTokenizeDate
-  let asUTC = newDateUTC(
-    tokens[0] as number,
-    (tokens[1] as number) - 1,
-    tokens[2] as number,
-    (tokens[3] as number) % 24,
-    tokens[4] as number,
-    tokens[5] as number,
-    0,
-  ).getTime();
+  const asUTC = newDateUTC(tokens[0], tokens[1] - 1, tokens[2], tokens[3] % 24, tokens[4], tokens[5], 0).getTime();
 
   let asTS = date.getTime();
-  let over = asTS % 1000;
+  const over = asTS % 1000;
   asTS -= over >= 0 ? over : 1000 + over;
   return asUTC - asTS;
 }
 
-function fixOffset(date: Date, offset: number, timezoneString: string): number {
-  let localTS = date.getTime();
+function fixOffset(date: Date, offset: number, timezoneString: string) {
+  const localTS = date.getTime();
 
   // Our UTC time is just a guess because our offset is just a guess
   let utcGuess = localTS - offset;
 
   // Test whether the zone matches the offset for this ts
-  let o2 = calcOffset(new Date(utcGuess), timezoneString);
+  const o2 = calcOffset(new Date(utcGuess), timezoneString);
 
   // If so, offset didn't change, and we're done
   if (offset === o2) {
@@ -120,7 +118,7 @@ function fixOffset(date: Date, offset: number, timezoneString: string): number {
   utcGuess -= o2 - offset;
 
   // If that gives us the local time we want, we're done
-  let o3 = calcOffset(new Date(utcGuess), timezoneString);
+  const o3 = calcOffset(new Date(utcGuess), timezoneString);
   if (o2 === o3) {
     return o2;
   }
@@ -129,12 +127,13 @@ function fixOffset(date: Date, offset: number, timezoneString: string): number {
   return Math.max(o2, o3);
 }
 
-function validateTimezone(hours: number, minutes?: number): boolean {
+function validateTimezone(hours: number, minutes?: number | null) {
   return -23 <= hours && hours <= 23 && (minutes == null || (0 <= minutes && minutes <= 59));
 }
 
-const validIANATimezoneCache = {} as Record<string, boolean>;
-function isValidTimezoneIANAString(timeZoneString: string): boolean {
+const validIANATimezoneCache: Record<string, boolean> = {};
+
+function isValidTimezoneIANAString(timeZoneString: string) {
   if (validIANATimezoneCache[timeZoneString]) return true;
   try {
     new Intl.DateTimeFormat(undefined, { timeZone: timeZoneString });
@@ -144,3 +143,5 @@ function isValidTimezoneIANAString(timeZoneString: string): boolean {
     return false;
   }
 }
+
+/* eslint-enable */

package/src/date-fns-tz/_lib/tzPattern/index.ts

@@ -1,4 +1,8 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
 /** Regex to identify the presence of a time zone specifier in a date string */
-const tzPattern = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
+export const tzPattern = /(Z|[+-]\d{2}(?::?\d{2})?| UTC| [a-zA-Z]+\/[a-zA-Z_]+(?:\/[a-zA-Z_]+)?)$/;
 
-export default tzPattern;
+/* eslint-enable */