@checkdigit/time 4.0.0-PR.18-9134 → 4.0.0-PR.18-e0fa

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

@@ -1,19 +1,14 @@
-import type { Match } from "../../../locale/types";
-import { setDay } from "../../../setDay/index";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult, ParserOptions } from "../types";
-import { mapValue, parseNDigits } from "../utils";
+import type { Match } from '../../../locale/types';
+import { setDay } from '../../../setDay/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { mapValue, parseNDigits } from '../utils';
 
 // Stand-alone local day of week
 export class StandAloneLocalDayParser extends Parser<number> {
   priority = 90;
 
-  parse(
-    dateString: string,
-    token: string,
-    match: Match,
-    options: ParserOptions,
-  ): ParseResult<number> {
+  parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<number> {
     const valueCallback = (value: number) => {
       // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
       const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
@@ -22,50 +17,50 @@ export class StandAloneLocalDayParser extends Parser<number> {
 
     switch (token) {
       // 3
-      case "c":
-      case "cc": // 03
+      case 'c':
+      case 'cc': // 03
         return mapValue(parseNDigits(token.length, dateString), valueCallback);
       // 3rd
-      case "co":
+      case 'co':
         return mapValue(
           match.ordinalNumber(dateString, {
-            unit: "day",
+            unit: 'day',
           }),
           valueCallback,
         );
       // Tue
-      case "ccc":
+      case 'ccc':
         return (
           match.day(dateString, {
-            width: "abbreviated",
-            context: "standalone",
+            width: 'abbreviated',
+            context: 'standalone',
           }) ||
-          match.day(dateString, { width: "short", context: "standalone" }) ||
-          match.day(dateString, { width: "narrow", context: "standalone" })
+          match.day(dateString, { width: 'short', context: 'standalone' }) ||
+          match.day(dateString, { width: 'narrow', context: 'standalone' })
         );
       // T
-      case "ccccc":
+      case 'ccccc':
         return match.day(dateString, {
-          width: "narrow",
-          context: "standalone",
+          width: 'narrow',
+          context: 'standalone',
         });
       // Tu
-      case "cccccc":
+      case 'cccccc':
         return (
-          match.day(dateString, { width: "short", context: "standalone" }) ||
-          match.day(dateString, { width: "narrow", context: "standalone" })
+          match.day(dateString, { width: 'short', context: 'standalone' }) ||
+          match.day(dateString, { width: 'narrow', context: 'standalone' })
         );
       // Tuesday
-      case "cccc":
+      case 'cccc':
       default:
         return (
-          match.day(dateString, { width: "wide", context: "standalone" }) ||
+          match.day(dateString, { width: 'wide', context: 'standalone' }) ||
           match.day(dateString, {
-            width: "abbreviated",
-            context: "standalone",
+            width: 'abbreviated',
+            context: 'standalone',
           }) ||
-          match.day(dateString, { width: "short", context: "standalone" }) ||
-          match.day(dateString, { width: "narrow", context: "standalone" })
+          match.day(dateString, { width: 'short', context: 'standalone' }) ||
+          match.day(dateString, { width: 'narrow', context: 'standalone' })
         );
     }
   }
@@ -74,32 +69,11 @@ export class StandAloneLocalDayParser extends Parser<number> {
     return value >= 0 && value <= 6;
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-    options: ParserOptions,
-  ): DateType {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType {
     date = setDay(date, value, options);
     date.setHours(0, 0, 0, 0);
     return date;
   }
 
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "E",
-    "i",
-    "e",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'E', 'i', 'e', 't', 'T'];
 }

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;