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

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

@@ -1,18 +1,13 @@
-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';
 
 // Local day of week
 export class LocalDayParser 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;
@@ -21,50 +16,50 @@ export class LocalDayParser extends Parser<number> {
 
     switch (token) {
       // 3
-      case "e":
-      case "ee": // 03
+      case 'e':
+      case 'ee': // 03
         return mapValue(parseNDigits(token.length, dateString), valueCallback);
       // 3rd
-      case "eo":
+      case 'eo':
         return mapValue(
           match.ordinalNumber(dateString, {
-            unit: "day",
+            unit: 'day',
           }),
           valueCallback,
         );
       // Tue
-      case "eee":
+      case 'eee':
         return (
           match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
+            width: 'abbreviated',
+            context: 'formatting',
           }) ||
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
+          match.day(dateString, { width: 'short', context: 'formatting' }) ||
+          match.day(dateString, { width: 'narrow', context: 'formatting' })
         );
       // T
-      case "eeeee":
+      case 'eeeee':
         return match.day(dateString, {
-          width: "narrow",
-          context: "formatting",
+          width: 'narrow',
+          context: 'formatting',
         });
       // Tu
-      case "eeeeee":
+      case 'eeeeee':
         return (
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
+          match.day(dateString, { width: 'short', context: 'formatting' }) ||
+          match.day(dateString, { width: 'narrow', context: 'formatting' })
         );
       // Tuesday
-      case "eeee":
+      case 'eeee':
       default:
         return (
-          match.day(dateString, { width: "wide", context: "formatting" }) ||
+          match.day(dateString, { width: 'wide', context: 'formatting' }) ||
           match.day(dateString, {
-            width: "abbreviated",
-            context: "formatting",
+            width: 'abbreviated',
+            context: 'formatting',
           }) ||
-          match.day(dateString, { width: "short", context: "formatting" }) ||
-          match.day(dateString, { width: "narrow", context: "formatting" })
+          match.day(dateString, { width: 'short', context: 'formatting' }) ||
+          match.day(dateString, { width: 'narrow', context: 'formatting' })
         );
     }
   }
@@ -73,32 +68,11 @@ export class LocalDayParser 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",
-    "c",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'E', 'i', 'c', 't', 'T'];
 }

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

@@ -1,10 +1,10 @@
-import type { Match } from "../../../locale/types";
-import { setWeek } from "../../../setWeek/index";
-import { startOfWeek } from "../../../startOfWeek/index";
-import { numericPatterns } from "../constants";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult, ParserOptions } from "../types";
-import { parseNDigits, parseNumericPattern } from "../utils";
+import type { Match } from '../../../locale/types';
+import { setWeek } from '../../../setWeek/index';
+import { startOfWeek } from '../../../startOfWeek/index';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { parseNDigits, parseNumericPattern } from '../utils';
 
 // Local week of year
 export class LocalWeekParser extends Parser<number> {
@@ -12,10 +12,10 @@ export class LocalWeekParser extends Parser<number> {
 
   parse(dateString: string, token: string, match: Match): ParseResult<number> {
     switch (token) {
-      case "w":
+      case 'w':
         return parseNumericPattern(numericPatterns.week, dateString);
-      case "wo":
-        return match.ordinalNumber(dateString, { unit: "week" });
+      case 'wo':
+        return match.ordinalNumber(dateString, { unit: 'week' });
       default:
         return parseNDigits(token.length, dateString);
     }
@@ -25,28 +25,9 @@ export class LocalWeekParser extends Parser<number> {
     return value >= 1 && value <= 53;
   }
 
-  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 {
     return startOfWeek(setWeek(date, value, options), options);
   }
 
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "i",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T'];
 }

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

@@ -1,32 +1,28 @@
-import { getWeekYear } from "../../../getWeekYear/index";
-import type { Match } from "../../../locale/types";
-import { startOfWeek } from "../../../startOfWeek/index";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult, ParserOptions } from "../types";
-import { mapValue, normalizeTwoDigitYear, parseNDigits } from "../utils";
-import type { YearParserValue } from "./YearParser";
+import { getWeekYear } from '../../../getWeekYear/index';
+import type { Match } from '../../../locale/types';
+import { startOfWeek } from '../../../startOfWeek/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { mapValue, normalizeTwoDigitYear, parseNDigits } from '../utils';
+import type { YearParserValue } from './YearParser';
 
 // Local week-numbering year
 export class LocalWeekYearParser extends Parser<YearParserValue> {
   priority = 130;
 
-  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,
         );
@@ -35,10 +31,7 @@ export class LocalWeekYearParser 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;
   }
 
@@ -51,39 +44,17 @@ export class LocalWeekYearParser extends Parser<YearParserValue> {
     const currentYear = getWeekYear(date, options);
 
     if (value.isTwoDigitYear) {
-      const normalizedTwoDigitYear = normalizeTwoDigitYear(
-        value.year,
-        currentYear,
-      );
-      date.setFullYear(
-        normalizedTwoDigitYear,
-        0,
-        options.firstWeekContainsDate,
-      );
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
+      date.setFullYear(normalizedTwoDigitYear, 0, options.firstWeekContainsDate);
       date.setHours(0, 0, 0, 0);
       return startOfWeek(date, options);
     }
 
-    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, options.firstWeekContainsDate);
     date.setHours(0, 0, 0, 0);
     return startOfWeek(date, options);
   }
 
-  incompatibleTokens = [
-    "y",
-    "R",
-    "u",
-    "Q",
-    "q",
-    "M",
-    "L",
-    "I",
-    "d",
-    "D",
-    "i",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['y', 'R', 'u', 'Q', 'q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T'];
 }

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

@@ -1,18 +1,18 @@
-import type { Match } from "../../../locale/types";
-import { numericPatterns } from "../constants";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { 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 { parseNDigits, parseNumericPattern } from '../utils';
 
 export class MinuteParser extends Parser<number> {
   priority = 60;
 
   parse(dateString: string, token: string, match: Match): ParseResult<number> {
     switch (token) {
-      case "m":
+      case 'm':
         return parseNumericPattern(numericPatterns.minute, dateString);
-      case "mo":
-        return match.ordinalNumber(dateString, { unit: "minute" });
+      case 'mo':
+        return match.ordinalNumber(dateString, { unit: 'minute' });
       default:
         return parseNDigits(token.length, dateString);
     }
@@ -22,14 +22,10 @@ export class MinuteParser extends Parser<number> {
     return value >= 0 && value <= 59;
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-  ): DateType {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
     date.setMinutes(value, 0, 0);
     return date;
   }
 
-  incompatibleTokens = ["t", "T"];
+  incompatibleTokens = ['t', 'T'];
 }

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

@@ -1,25 +1,11 @@
-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 MonthParser extends Parser<number> {
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "L",
-    "w",
-    "I",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T",
-  ];
+  incompatibleTokens = ['Y', 'R', 'q', 'Q', 'L', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'];
   priority = 110;
 
   parse(dateString: string, token: string, match: Match): ParseResult<number> {
@@ -27,47 +13,43 @@ export class MonthParser extends Parser<number> {
 
     switch (token) {
       // 1, 2, ..., 12
-      case "M":
-        return mapValue(
-          parseNumericPattern(numericPatterns.month, dateString),
-          valueCallback,
-        );
+      case 'M':
+        return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
       // 01, 02, ..., 12
-      case "MM":
+      case 'MM':
         return mapValue(parseNDigits(2, dateString), valueCallback);
       // 1st, 2nd, ..., 12th
-      case "Mo":
+      case 'Mo':
         return mapValue(
           match.ordinalNumber(dateString, {
-            unit: "month",
+            unit: 'month',
           }),
           valueCallback,
         );
       // Jan, Feb, ..., Dec
-      case "MMM":
+      case 'MMM':
         return (
           match.month(dateString, {
-            width: "abbreviated",
-            context: "formatting",
-          }) ||
-          match.month(dateString, { width: "narrow", context: "formatting" })
+            width: 'abbreviated',
+            context: 'formatting',
+          }) || match.month(dateString, { width: 'narrow', context: 'formatting' })
         );
       // J, F, ..., D
-      case "MMMMM":
+      case 'MMMMM':
         return match.month(dateString, {
-          width: "narrow",
-          context: "formatting",
+          width: 'narrow',
+          context: 'formatting',
         });
       // January, February, ..., December
-      case "MMMM":
+      case 'MMMM':
       default:
         return (
-          match.month(dateString, { width: "wide", context: "formatting" }) ||
+          match.month(dateString, { width: 'wide', context: 'formatting' }) ||
           match.month(dateString, {
-            width: "abbreviated",
-            context: "formatting",
+            width: 'abbreviated',
+            context: 'formatting',
           }) ||
-          match.month(dateString, { width: "narrow", context: "formatting" })
+          match.month(dateString, { width: 'narrow', context: 'formatting' })
         );
     }
   }
@@ -76,11 +58,7 @@ export class MonthParser 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;

package/src/date-fns/parse/_lib/parsers/QuarterParser.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 QuarterParser extends Parser<number> {
   priority = 120;
@@ -9,45 +9,45 @@ export class QuarterParser 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: "formatting",
+            width: 'abbreviated',
+            context: 'formatting',
           }) ||
           match.quarter(dateString, {
-            width: "narrow",
-            context: "formatting",
+            width: 'narrow',
+            context: 'formatting',
           })
         );
       // 1, 2, 3, 4 (narrow quarter; could be not numerical)
-      case "QQQQQ":
+      case 'QQQQQ':
         return match.quarter(dateString, {
-          width: "narrow",
-          context: "formatting",
+          width: 'narrow',
+          context: 'formatting',
         });
       // 1st quarter, 2nd quarter, ...
-      case "QQQQ":
+      case 'QQQQ':
       default:
         return (
           match.quarter(dateString, {
-            width: "wide",
-            context: "formatting",
+            width: 'wide',
+            context: 'formatting',
           }) ||
           match.quarter(dateString, {
-            width: "abbreviated",
-            context: "formatting",
+            width: 'abbreviated',
+            context: 'formatting',
           }) ||
           match.quarter(dateString, {
-            width: "narrow",
-            context: "formatting",
+            width: 'narrow',
+            context: 'formatting',
           })
         );
     }
@@ -57,30 +57,11 @@ export class QuarterParser 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/SecondParser.ts

@@ -1,18 +1,18 @@
-import type { Match } from "../../../locale/types";
-import { numericPatterns } from "../constants";
-import { Parser } from "../Parser";
-import type { ParseFlags, ParseResult } from "../types";
-import { 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 { parseNDigits, parseNumericPattern } from '../utils';
 
 export class SecondParser extends Parser<number> {
   priority = 50;
 
   parse(dateString: string, token: string, match: Match): ParseResult<number> {
     switch (token) {
-      case "s":
+      case 's':
         return parseNumericPattern(numericPatterns.second, dateString);
-      case "so":
-        return match.ordinalNumber(dateString, { unit: "second" });
+      case 'so':
+        return match.ordinalNumber(dateString, { unit: 'second' });
       default:
         return parseNDigits(token.length, dateString);
     }
@@ -22,14 +22,10 @@ export class SecondParser extends Parser<number> {
     return value >= 0 && value <= 59;
   }
 
-  set<DateType extends Date>(
-    date: DateType,
-    _flags: ParseFlags,
-    value: number,
-  ): DateType {
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
     date.setSeconds(value, 0);
     return date;
   }
 
-  incompatibleTokens = ["t", "T"];
+  incompatibleTokens = ['t', 'T'];
 }