@checkdigit/time 4.0.0-PR.18-9134 → 4.0.0-PR.18-81a3

package/src/date-fns/parse/_lib/parsers/StandAloneMonthParser.ts

@@ -1,8 +1,8 @@
-import type { Match } from "../../../locale/types";
-import { numericPatterns } from "../constants";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { mapValue, parseNDigits, parseNumericPattern } from "../utils";
+import type { Match } from '../../../locale/types';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { mapValue, parseNDigits, parseNumericPattern } from '../utils';
 
 export class StandAloneMonthParser extends Parser<number> {
   priority = 110;
@@ -12,47 +12,43 @@ export class StandAloneMonthParser extends Parser<number> {
 
     switch (token) {
       // 1, 2, ..., 12
-      case "L":
-        return mapValue(
-          parseNumericPattern(numericPatterns.month, dateString),
-          valueCallback,
-        );
+      case 'L':
+        return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
       // 01, 02, ..., 12
-      case "LL":
+      case 'LL':
         return mapValue(parseNDigits(2, dateString), valueCallback);
       // 1st, 2nd, ..., 12th
-      case "Lo":
+      case 'Lo':
         return mapValue(
           match.ordinalNumber(dateString, {
-            unit: "month",
+            unit: 'month',
           }),
           valueCallback,
         );
       // Jan, Feb, ..., Dec
-      case "LLL":
+      case 'LLL':
         return (
           match.month(dateString, {
-            width: "abbreviated",
-            context: "standalone",
-          }) ||
-          match.month(dateString, { width: "narrow", context: "standalone" })
+            width: 'abbreviated',
+            context: 'standalone',
+          }) || match.month(dateString, { width: 'narrow', context: 'standalone' })
         );
       // J, F, ..., D
-      case "LLLLL":
+      case 'LLLLL':
         return match.month(dateString, {
-          width: "narrow",
-          context: "standalone",
+          width: 'narrow',
+          context: 'standalone',
         });
       // January, February, ..., December
-      case "LLLL":
+      case 'LLLL':
       default:
         return (
-          match.month(dateString, { width: "wide", context: "standalone" }) ||
+          match.month(dateString, { width: 'wide', context: 'standalone' }) ||
           match.month(dateString, {
-            width: "abbreviated",
-            context: "standalone",
+            width: 'abbreviated',
+            context: 'standalone',
           }) ||
-          match.month(dateString, { width: "narrow", context: "standalone" })
+          match.month(dateString, { width: 'narrow', context: 'standalone' })
         );
     }
   }
@@ -61,29 +57,11 @@ export class StandAloneMonthParser extends Parser<number> {
     return value >= 0 && value <= 11;
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-  ): DateType {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
     date.setMonth(value, 1);
     date.setHours(0, 0, 0, 0);
     return date;
   }
 
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "M",
-    "w",
-    "I",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['Y', 'R', 'q', 'Q', 'M', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'];
 }

package/src/date-fns/parse/_lib/parsers/StandAloneQuarterParser.ts

@@ -1,7 +1,7 @@
-import type { Match } from "../../../locale/types";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { parseNDigits } from "../utils";
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigits } from '../utils';
 
 export class StandAloneQuarterParser extends Parser<number> {
   priority = 120;
@@ -9,45 +9,45 @@ export class StandAloneQuarterParser extends Parser<number> {
   parse(dateString: string, token: string, match: Match): ParseResult<number> {
     switch (token) {
       // 1, 2, 3, 4
-      case "q":
-      case "qq": // 01, 02, 03, 04
+      case 'q':
+      case 'qq': // 01, 02, 03, 04
         return parseNDigits(token.length, dateString);
       // 1st, 2nd, 3rd, 4th
-      case "qo":
-        return match.ordinalNumber(dateString, { unit: "quarter" });
+      case 'qo':
+        return match.ordinalNumber(dateString, { unit: 'quarter' });
       // Q1, Q2, Q3, Q4
-      case "qqq":
+      case 'qqq':
         return (
           match.quarter(dateString, {
-            width: "abbreviated",
-            context: "standalone",
+            width: 'abbreviated',
+            context: 'standalone',
           }) ||
           match.quarter(dateString, {
-            width: "narrow",
-            context: "standalone",
+            width: 'narrow',
+            context: 'standalone',
           })
         );
       // 1, 2, 3, 4 (narrow quarter; could be not numerical)
-      case "qqqqq":
+      case 'qqqqq':
         return match.quarter(dateString, {
-          width: "narrow",
-          context: "standalone",
+          width: 'narrow',
+          context: 'standalone',
         });
       // 1st quarter, 2nd quarter, ...
-      case "qqqq":
+      case 'qqqq':
       default:
         return (
           match.quarter(dateString, {
-            width: "wide",
-            context: "standalone",
+            width: 'wide',
+            context: 'standalone',
           }) ||
           match.quarter(dateString, {
-            width: "abbreviated",
-            context: "standalone",
+            width: 'abbreviated',
+            context: 'standalone',
           }) ||
           match.quarter(dateString, {
-            width: "narrow",
-            context: "standalone",
+            width: 'narrow',
+            context: 'standalone',
           })
         );
     }
@@ -57,30 +57,11 @@ export class StandAloneQuarterParser extends Parser<number> {
     return value >= 1 && value <= 4;
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-  ): DateType {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
     date.setMonth((value - 1) * 3, 1);
     date.setHours(0, 0, 0, 0);
     return date;
   }
 
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "Q",
-    "M",
-    "L",
-    "w",
-    "I",
-    "d",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['Y', 'R', 'Q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T'];
 }

package/src/date-fns/parse/_lib/parsers/TimestampMillisecondsParser.ts

@@ -1,7 +1,7 @@
-import { constructFrom } from "../../../constructFrom/index";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { parseAnyDigitsSigned } from "../utils";
+import { constructFrom } from '../../../constructFrom/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseAnyDigitsSigned } from '../utils';
 
 export class TimestampMillisecondsParser extends Parser<number> {
   priority = 20;
@@ -10,13 +10,9 @@ export class TimestampMillisecondsParser extends Parser<number> {
     return parseAnyDigitsSigned(dateString);
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-  ): [DateType, ParseFlags] {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): [DateType, ParseFlags] {
     return [constructFrom(date, value), { timestampIsSet: true }];
   }
 
-  incompatibleTokens = "*" as const;
+  incompatibleTokens = '*' as const;
 }

package/src/date-fns/parse/_lib/parsers/TimestampSecondsParser.ts

@@ -1,7 +1,7 @@
-import { constructFrom } from "../../../constructFrom/index";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { parseAnyDigitsSigned } from "../utils";
+import { constructFrom } from '../../../constructFrom/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseAnyDigitsSigned } from '../utils';
 
 export class TimestampSecondsParser extends Parser<number> {
   priority = 40;
@@ -10,13 +10,9 @@ export class TimestampSecondsParser extends Parser<number> {
     return parseAnyDigitsSigned(dateString);
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-  ): [DateType, ParseFlags] {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): [DateType, ParseFlags] {
     return [constructFrom(date, value * 1000), { timestampIsSet: true }];
   }
 
-  incompatibleTokens = "*" as const;
+  incompatibleTokens = '*' as const;
 }

package/src/date-fns/parse/_lib/parsers/YearParser.ts

@@ -1,7 +1,7 @@
-import type { Match } from "../../../locale/types";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { mapValue, normalizeTwoDigitYear, parseNDigits } from "../utils";
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { mapValue, normalizeTwoDigitYear, parseNDigits } from '../utils';
 
 export interface YearParserValue {
   year: number;
@@ -18,25 +18,21 @@ export interface YearParserValue {
 // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
 export class YearParser extends Parser<YearParserValue> {
   priority = 130;
-  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+  incompatibleTokens = ['Y', 'R', 'u', 'w', 'I', 'i', 'e', 'c', 't', 'T'];
 
-  parse(
-    dateString: string,
-    token: string,
-    match: Match,
-  ): ParseResult<YearParserValue> {
+  parse(dateString: string, token: string, match: Match): ParseResult<YearParserValue> {
     const valueCallback = (year: number) => ({
       year,
-      isTwoDigitYear: token === "yy",
+      isTwoDigitYear: token === 'yy',
     });
 
     switch (token) {
-      case "y":
+      case 'y':
         return mapValue(parseNDigits(4, dateString), valueCallback);
-      case "yo":
+      case 'yo':
         return mapValue(
           match.ordinalNumber(dateString, {
-            unit: "year",
+            unit: 'year',
           }),
           valueCallback,
         );
@@ -45,32 +41,21 @@ export class YearParser extends Parser<YearParserValue> {
     }
   }
 
-  override validate<DateType extends Date>(
-    _date: DateType,
-    value: YearParserValue,
-  ): boolean {
+  override validate<DateType extends Date>(_date: DateType, value: YearParserValue): boolean {
     return value.isTwoDigitYear || value.year > 0;
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    flags: ParseFlags,
-    value: YearParserValue,
-  ): DateType {
+  set<DateType extends Date>(date: DateType, flags: ParseFlags, value: YearParserValue): DateType {
     const currentYear = date.getFullYear();
 
     if (value.isTwoDigitYear) {
-      const normalizedTwoDigitYear = normalizeTwoDigitYear(
-        value.year,
-        currentYear,
-      );
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
       date.setFullYear(normalizedTwoDigitYear, 0, 1);
       date.setHours(0, 0, 0, 0);
       return date;
     }
 
-    const year =
-      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    const year = !('era' in flags) || flags.era === 1 ? value.year : 1 - value.year;
     date.setFullYear(year, 0, 1);
     date.setHours(0, 0, 0, 0);
     return date;

package/src/date-fns/parse/_lib/parsers/index.ts

@@ -1,35 +1,35 @@
-import type { Parser } from "../Parser";
-import { EraParser } from "./EraParser";
-import { YearParser } from "./YearParser";
-import { LocalWeekYearParser } from "./LocalWeekYearParser";
-import { ISOWeekYearParser } from "./ISOWeekYearParser";
-import { ExtendedYearParser } from "./ExtendedYearParser";
-import { QuarterParser } from "./QuarterParser";
-import { StandAloneQuarterParser } from "./StandAloneQuarterParser";
-import { MonthParser } from "./MonthParser";
-import { StandAloneMonthParser } from "./StandAloneMonthParser";
-import { LocalWeekParser } from "./LocalWeekParser";
-import { ISOWeekParser } from "./ISOWeekParser";
-import { DateParser } from "./DateParser";
-import { DayOfYearParser } from "./DayOfYearParser";
-import { DayParser } from "./DayParser";
-import { LocalDayParser } from "./LocalDayParser";
-import { StandAloneLocalDayParser } from "./StandAloneLocalDayParser";
-import { ISODayParser } from "./ISODayParser";
-import { AMPMParser } from "./AMPMParser";
-import { AMPMMidnightParser } from "./AMPMMidnightParser";
-import { DayPeriodParser } from "./DayPeriodParser";
-import { Hour1to12Parser } from "./Hour1to12Parser";
-import { Hour0to23Parser } from "./Hour0to23Parser";
-import { Hour0To11Parser } from "./Hour0To11Parser";
-import { Hour1To24Parser } from "./Hour1To24Parser";
-import { MinuteParser } from "./MinuteParser";
-import { SecondParser } from "./SecondParser";
-import { FractionOfSecondParser } from "./FractionOfSecondParser";
-import { ISOTimezoneWithZParser } from "./ISOTimezoneWithZParser";
-import { ISOTimezoneParser } from "./ISOTimezoneParser";
-import { TimestampSecondsParser } from "./TimestampSecondsParser";
-import { TimestampMillisecondsParser } from "./TimestampMillisecondsParser";
+import type { Parser } from '../Parser';
+import { EraParser } from './EraParser';
+import { YearParser } from './YearParser';
+import { LocalWeekYearParser } from './LocalWeekYearParser';
+import { ISOWeekYearParser } from './ISOWeekYearParser';
+import { ExtendedYearParser } from './ExtendedYearParser';
+import { QuarterParser } from './QuarterParser';
+import { StandAloneQuarterParser } from './StandAloneQuarterParser';
+import { MonthParser } from './MonthParser';
+import { StandAloneMonthParser } from './StandAloneMonthParser';
+import { LocalWeekParser } from './LocalWeekParser';
+import { ISOWeekParser } from './ISOWeekParser';
+import { DateParser } from './DateParser';
+import { DayOfYearParser } from './DayOfYearParser';
+import { DayParser } from './DayParser';
+import { LocalDayParser } from './LocalDayParser';
+import { StandAloneLocalDayParser } from './StandAloneLocalDayParser';
+import { ISODayParser } from './ISODayParser';
+import { AMPMParser } from './AMPMParser';
+import { AMPMMidnightParser } from './AMPMMidnightParser';
+import { DayPeriodParser } from './DayPeriodParser';
+import { Hour1to12Parser } from './Hour1to12Parser';
+import { Hour0to23Parser } from './Hour0to23Parser';
+import { Hour0To11Parser } from './Hour0To11Parser';
+import { Hour1To24Parser } from './Hour1To24Parser';
+import { MinuteParser } from './MinuteParser';
+import { SecondParser } from './SecondParser';
+import { FractionOfSecondParser } from './FractionOfSecondParser';
+import { ISOTimezoneWithZParser } from './ISOTimezoneWithZParser';
+import { ISOTimezoneParser } from './ISOTimezoneParser';
+import { TimestampSecondsParser } from './TimestampSecondsParser';
+import { TimestampMillisecondsParser } from './TimestampMillisecondsParser';
 
 /*
  * |     | Unit                           |     | Unit                           |

package/src/date-fns/parse/_lib/types.ts

@@ -1,16 +1,10 @@
-import type {
-  LocalizedOptions,
-  FirstWeekContainsDateOptions,
-  WeekOptions,
-} from "../../types";
+import type { LocalizedOptions, FirstWeekContainsDateOptions, WeekOptions } from '../../types';
 
 export interface ParseFlags {
   timestampIsSet?: boolean;
   era?: number;
 }
 
-export type ParserOptions = Required<
-  LocalizedOptions<"options"> & FirstWeekContainsDateOptions & WeekOptions
->;
+export type ParserOptions = Required<LocalizedOptions<'options'> & FirstWeekContainsDateOptions & WeekOptions>;
 
 export type ParseResult<TValue> = { value: TValue; rest: string } | null;

package/src/date-fns/parse/_lib/utils.ts

@@ -1,11 +1,7 @@
-import type { LocaleDayPeriod } from "../../locale/types";
-import {
-  millisecondsInHour,
-  millisecondsInMinute,
-  millisecondsInSecond,
-} from "../../constants/index";
-import type { ParseResult } from "./types";
-import { numericPatterns } from "./constants";
+import type { LocaleDayPeriod } from '../../locale/types';
+import { millisecondsInHour, millisecondsInMinute, millisecondsInSecond } from '../../constants/index';
+import type { ParseResult } from './types';
+import { numericPatterns } from './constants';
 
 export function mapValue<TInput, TResult>(
   parseFnResult: ParseResult<TInput>,
@@ -21,10 +17,7 @@ export function mapValue<TInput, TResult>(
   };
 }
 
-export function parseNumericPattern(
-  pattern: RegExp,
-  dateString: string,
-): ParseResult<number> {
+export function parseNumericPattern(pattern: RegExp, dateString: string): ParseResult<number> {
   const matchResult = dateString.match(pattern);
 
   if (!matchResult) {
@@ -37,10 +30,7 @@ export function parseNumericPattern(
   };
 }
 
-export function parseTimezonePattern(
-  pattern: RegExp,
-  dateString: string,
-): ParseResult<number> {
+export function parseTimezonePattern(pattern: RegExp, dateString: string): ParseResult<number> {
   const matchResult = dateString.match(pattern);
 
   if (!matchResult) {
@@ -48,24 +38,20 @@ export function parseTimezonePattern(
   }
 
   // Input is 'Z'
-  if (matchResult[0] === "Z") {
+  if (matchResult[0] === 'Z') {
     return {
       value: 0,
       rest: dateString.slice(1),
     };
   }
 
-  const sign = matchResult[1] === "+" ? 1 : -1;
+  const sign = matchResult[1] === '+' ? 1 : -1;
   const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
   const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
   const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
 
   return {
-    value:
-      sign *
-      (hours * millisecondsInHour +
-        minutes * millisecondsInMinute +
-        seconds * millisecondsInSecond),
+    value: sign * (hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
     rest: dateString.slice(matchResult[0].length),
   };
 }
@@ -74,10 +60,7 @@ export function parseAnyDigitsSigned(dateString: string): ParseResult<number> {
   return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
 }
 
-export function parseNDigits(
-  n: number,
-  dateString: string,
-): ParseResult<number> {
+export function parseNDigits(n: number, dateString: string): ParseResult<number> {
   switch (n) {
     case 1:
       return parseNumericPattern(numericPatterns.singleDigit, dateString);
@@ -88,14 +71,11 @@ export function parseNDigits(
     case 4:
       return parseNumericPattern(numericPatterns.fourDigits, dateString);
     default:
-      return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
+      return parseNumericPattern(new RegExp('^\\d{1,' + n + '}'), dateString);
   }
 }
 
-export function parseNDigitsSigned(
-  n: number,
-  dateString: string,
-): ParseResult<number> {
+export function parseNDigitsSigned(n: number, dateString: string): ParseResult<number> {
   switch (n) {
     case 1:
       return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
@@ -106,32 +86,29 @@ export function parseNDigitsSigned(
     case 4:
       return parseNumericPattern(numericPatterns.fourDigitsSigned, dateString);
     default:
-      return parseNumericPattern(new RegExp("^-?\\d{1," + n + "}"), dateString);
+      return parseNumericPattern(new RegExp('^-?\\d{1,' + n + '}'), dateString);
   }
 }
 
 export function dayPeriodEnumToHours(dayPeriod: LocaleDayPeriod): number {
   switch (dayPeriod) {
-    case "morning":
+    case 'morning':
       return 4;
-    case "evening":
+    case 'evening':
       return 17;
-    case "pm":
-    case "noon":
-    case "afternoon":
+    case 'pm':
+    case 'noon':
+    case 'afternoon':
       return 12;
-    case "am":
-    case "midnight":
-    case "night":
+    case 'am':
+    case 'midnight':
+    case 'night':
     default:
       return 0;
   }
 }
 
-export function normalizeTwoDigitYear(
-  twoDigitYear: number,
-  currentYear: number,
-): number {
+export function normalizeTwoDigitYear(twoDigitYear: number, currentYear: number): number {
   const isCommonEra = currentYear > 0;
   // Absolute number of the current year:
   // 1 -> 1 AC