@checkdigit/time 1.0.0-PR.11-fede → 1.1.0

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

@@ -1,54 +0,0 @@
-import type { LocaleDayPeriod, Match } from '../../../locale/types';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { dayPeriodEnumToHours } from '../utils';
-
-export class AMPMMidnightParser extends Parser<LocaleDayPeriod> {
-  priority = 80;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<LocaleDayPeriod> {
-    switch (token) {
-      case 'b':
-      case 'bb':
-      case 'bbb':
-        return (
-          match.dayPeriod(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          })
-        );
-      case 'bbbbb':
-        return match.dayPeriod(dateString, {
-          width: 'narrow',
-          context: 'formatting',
-        });
-      case 'bbbb':
-      default:
-        return (
-          match.dayPeriod(dateString, {
-            width: 'wide',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          })
-        );
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: LocaleDayPeriod): DateType {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['a', 'B', 'H', 'k', 't', 'T'];
-}

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

@@ -1,54 +0,0 @@
-import type { LocaleDayPeriod, Match } from '../../../locale/types';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { dayPeriodEnumToHours } from '../utils';
-
-export class AMPMParser extends Parser<LocaleDayPeriod> {
-  priority = 80;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<LocaleDayPeriod> {
-    switch (token) {
-      case 'a':
-      case 'aa':
-      case 'aaa':
-        return (
-          match.dayPeriod(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          })
-        );
-      case 'aaaaa':
-        return match.dayPeriod(dateString, {
-          width: 'narrow',
-          context: 'formatting',
-        });
-      case 'aaaa':
-      default:
-        return (
-          match.dayPeriod(dateString, {
-            width: 'wide',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          })
-        );
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: LocaleDayPeriod): DateType {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['b', 'B', 'H', 'k', 't', 'T'];
-}

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

@@ -1,44 +0,0 @@
-import type { Match } from '../../../locale/types';
-import { numericPatterns } from '../constants';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { isLeapYearIndex, parseNDigits, parseNumericPattern } from '../utils';
-
-const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const DAYS_IN_MONTH_LEAP_YEAR = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-
-// Day of the month
-export class DateParser extends Parser<number> {
-  priority = 90;
-  override subPriority = 1;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      case 'd':
-        return parseNumericPattern(numericPatterns.date, dateString);
-      case 'do':
-        return match.ordinalNumber(dateString, { unit: 'date' });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  override validate<DateType extends Date>(date: DateType, value: number): boolean {
-    const year = date.getFullYear();
-    const isLeapYear = isLeapYearIndex(year);
-    const month = date.getMonth();
-    if (isLeapYear) {
-      return value >= 1 && value <= (DAYS_IN_MONTH_LEAP_YEAR[month] as number);
-    } else {
-      return value >= 1 && value <= (DAYS_IN_MONTH[month] as number);
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    date.setDate(value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['Y', 'R', 'q', 'Q', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'];
-}

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

@@ -1,41 +0,0 @@
-import type { Match } from '../../../locale/types';
-import { numericPatterns } from '../constants';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { isLeapYearIndex, parseNDigits, parseNumericPattern } from '../utils';
-
-export class DayOfYearParser extends Parser<number> {
-  priority = 90;
-
-  subpriority = 1;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      case 'D':
-      case 'DD':
-        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
-      case 'Do':
-        return match.ordinalNumber(dateString, { unit: 'date' });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  override validate<DateType extends Date>(date: DateType, value: number): boolean {
-    const year = date.getFullYear();
-    const isLeapYear = isLeapYearIndex(year);
-    if (isLeapYear) {
-      return value >= 1 && value <= 366;
-    } else {
-      return value >= 1 && value <= 365;
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    date.setMonth(0, value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['Y', 'R', 'q', 'Q', 'M', 'L', 'w', 'I', 'd', 'E', 'i', 'e', 'c', 't', 'T'];
-}

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

@@ -1,62 +0,0 @@
-import type { Match } from '../../../locale/types';
-import setDay from '../../../setDay/index';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult, ParserOptions } from '../types';
-
-// Day of week
-export class DayParser extends Parser<number> {
-  priority = 90;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      // Tue
-      case 'E':
-      case 'EE':
-      case 'EEE':
-        return (
-          match.day(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.day(dateString, { width: 'short', context: 'formatting' }) ||
-          match.day(dateString, { width: 'narrow', context: 'formatting' })
-        );
-      // T
-      case 'EEEEE':
-        return match.day(dateString, {
-          width: 'narrow',
-          context: 'formatting',
-        });
-      // Tu
-      case 'EEEEEE':
-        return (
-          match.day(dateString, { width: 'short', context: 'formatting' }) ||
-          match.day(dateString, { width: 'narrow', context: 'formatting' })
-        );
-      // Tuesday
-      case 'EEEE':
-      default:
-        return (
-          match.day(dateString, { width: 'wide', context: 'formatting' }) ||
-          match.day(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.day(dateString, { width: 'short', context: 'formatting' }) ||
-          match.day(dateString, { width: 'narrow', context: 'formatting' })
-        );
-    }
-  }
-
-  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
-    return value >= 0 && value <= 6;
-  }
-
-  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 = ['D', 'i', 'e', 'c', 't', 'T'];
-}

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

@@ -1,55 +0,0 @@
-import type { LocaleDayPeriod, Match } from '../../../locale/types';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { dayPeriodEnumToHours } from '../utils';
-
-// in the morning, in the afternoon, in the evening, at night
-export class DayPeriodParser extends Parser<LocaleDayPeriod> {
-  priority = 80;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<LocaleDayPeriod> {
-    switch (token) {
-      case 'B':
-      case 'BB':
-      case 'BBB':
-        return (
-          match.dayPeriod(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          })
-        );
-      case 'BBBBB':
-        return match.dayPeriod(dateString, {
-          width: 'narrow',
-          context: 'formatting',
-        });
-      case 'BBBB':
-      default:
-        return (
-          match.dayPeriod(dateString, {
-            width: 'wide',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-          match.dayPeriod(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          })
-        );
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: LocaleDayPeriod): DateType {
-    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['a', 'b', 't', 'T'];
-}

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

@@ -1,38 +0,0 @@
-import type { Match } from '../../../locale/types';
-import type { Era } from '../../../types';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-
-export class EraParser extends Parser<number> {
-  priority = 140;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<Era> {
-    switch (token) {
-      // AD, BC
-      case 'G':
-      case 'GG':
-      case 'GGG':
-        return match.era(dateString, { width: 'abbreviated' }) || match.era(dateString, { width: 'narrow' });
-      // A, B
-      case 'GGGGG':
-        return match.era(dateString, { width: 'narrow' });
-      // Anno Domini, Before Christ
-      case 'GGGG':
-      default:
-        return (
-          match.era(dateString, { width: 'wide' }) ||
-          match.era(dateString, { width: 'abbreviated' }) ||
-          match.era(dateString, { width: 'narrow' })
-        );
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, flags: ParseFlags, value: number): DateType {
-    flags.era = value;
-    date.setFullYear(value, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['R', 'u', 't', 'T'];
-}

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

@@ -1,23 +0,0 @@
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { parseNDigitsSigned } from '../utils';
-
-export class ExtendedYearParser extends Parser<number> {
-  priority = 130;
-
-  parse(dateString: string, token: string): ParseResult<number> {
-    if (token === 'u') {
-      return parseNDigitsSigned(4, dateString);
-    }
-
-    return parseNDigitsSigned(token.length, dateString);
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    date.setFullYear(value, 0, 1);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['G', 'y', 'Y', 'R', 'w', 'I', 'i', 'e', 'c', 't', 'T'];
-}

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

@@ -1,19 +0,0 @@
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { mapValue, parseNDigits } from '../utils';
-
-export class FractionOfSecondParser extends Parser<number> {
-  priority = 30;
-
-  parse(dateString: string, token: string): ParseResult<number> {
-    const valueCallback = (value: number) => Math.floor(value * Math.pow(10, -token.length + 3));
-    return mapValue(parseNDigits(token.length, dateString), valueCallback);
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    date.setMilliseconds(value);
-    return date;
-  }
-
-  incompatibleTokens = ['t', 'T'];
-}

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

@@ -1,36 +0,0 @@
-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 Hour0To11Parser extends Parser<number> {
-  priority = 70;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      case 'K':
-        return parseNumericPattern(numericPatterns.hour11h, dateString);
-      case 'Ko':
-        return match.ordinalNumber(dateString, { unit: 'hour' });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
-    return value >= 0 && value <= 11;
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    const isPM = date.getHours() >= 12;
-    if (isPM && value < 12) {
-      date.setHours(value + 12, 0, 0, 0);
-    } else {
-      date.setHours(value, 0, 0, 0);
-    }
-    return date;
-  }
-
-  incompatibleTokens = ['h', 'H', 'k', 't', 'T'];
-}

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

@@ -1,31 +0,0 @@
-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 Hour0to23Parser extends Parser<number> {
-  priority = 70;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      case 'H':
-        return parseNumericPattern(numericPatterns.hour23h, dateString);
-      case 'Ho':
-        return match.ordinalNumber(dateString, { unit: 'hour' });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
-    return value >= 0 && value <= 23;
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    date.setHours(value, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['a', 'b', 'h', 'K', 'k', 't', 'T'];
-}

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

@@ -1,32 +0,0 @@
-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 Hour1To24Parser extends Parser<number> {
-  priority = 70;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      case 'k':
-        return parseNumericPattern(numericPatterns.hour24h, dateString);
-      case 'ko':
-        return match.ordinalNumber(dateString, { unit: 'hour' });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
-    return value >= 1 && value <= 24;
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    const hours = value <= 24 ? value % 24 : value;
-    date.setHours(hours, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['a', 'b', 'h', 'H', 'K', 't', 'T'];
-}

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

@@ -1,38 +0,0 @@
-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 Hour1to12Parser extends Parser<number> {
-  priority = 70;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    switch (token) {
-      case 'h':
-        return parseNumericPattern(numericPatterns.hour12h, dateString);
-      case 'ho':
-        return match.ordinalNumber(dateString, { unit: 'hour' });
-      default:
-        return parseNDigits(token.length, dateString);
-    }
-  }
-
-  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
-    return value >= 1 && value <= 12;
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    const isPM = date.getHours() >= 12;
-    if (isPM && value < 12) {
-      date.setHours(value + 12, 0, 0, 0);
-    } else if (!isPM && value === 12) {
-      date.setHours(0, 0, 0, 0);
-    } else {
-      date.setHours(value, 0, 0, 0);
-    }
-    return date;
-  }
-
-  incompatibleTokens = ['H', 'K', 'k', 't', 'T'];
-}

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

@@ -1,102 +0,0 @@
-import type { Match } from '../../../locale/types';
-import setISODay from '../../../setISODay/index';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { mapValue, parseNDigits } from '../utils';
-
-// ISO day of week
-export class ISODayParser extends Parser<number> {
-  priority = 90;
-
-  parse(dateString: string, token: string, match: Match): ParseResult<number> {
-    const valueCallback = (value: number) => {
-      if (value === 0) {
-        return 7;
-      }
-      return value;
-    };
-
-    switch (token) {
-      // 2
-      case 'i':
-      case 'ii': // 02
-        return parseNDigits(token.length, dateString);
-      // 2nd
-      case 'io':
-        return match.ordinalNumber(dateString, { unit: 'day' });
-      // Tue
-      case 'iii':
-        return mapValue(
-          match.day(dateString, {
-            width: 'abbreviated',
-            context: 'formatting',
-          }) ||
-            match.day(dateString, {
-              width: 'short',
-              context: 'formatting',
-            }) ||
-            match.day(dateString, {
-              width: 'narrow',
-              context: 'formatting',
-            }),
-          valueCallback
-        );
-      // T
-      case 'iiiii':
-        return mapValue(
-          match.day(dateString, {
-            width: 'narrow',
-            context: 'formatting',
-          }),
-          valueCallback
-        );
-      // Tu
-      case 'iiiiii':
-        return mapValue(
-          match.day(dateString, {
-            width: 'short',
-            context: 'formatting',
-          }) ||
-            match.day(dateString, {
-              width: 'narrow',
-              context: 'formatting',
-            }),
-          valueCallback
-        );
-      // Tuesday
-      case 'iiii':
-      default:
-        return mapValue(
-          match.day(dateString, {
-            width: 'wide',
-            context: 'formatting',
-          }) ||
-            match.day(dateString, {
-              width: 'abbreviated',
-              context: 'formatting',
-            }) ||
-            match.day(dateString, {
-              width: 'short',
-              context: 'formatting',
-            }) ||
-            match.day(dateString, {
-              width: 'narrow',
-              context: 'formatting',
-            }),
-          valueCallback
-        );
-    }
-  }
-
-  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
-    return value >= 1 && value <= 7;
-  }
-
-  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
-    date = setISODay(date, value);
-    date.setHours(0, 0, 0, 0);
-    return date;
-  }
-
-  incompatibleTokens = ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'E', 'e', 'c', 't', 'T'];
-}

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

@@ -1,34 +0,0 @@
-import constructFrom from '../../../constructFrom/index';
-import getTimezoneOffsetInMilliseconds from '../../../_lib/getTimezoneOffsetInMilliseconds/index';
-import { timezonePatterns } from '../constants';
-import { Parser } from '../Parser';
-import type { ParseFlags, ParseResult } from '../types';
-import { parseTimezonePattern } from '../utils';
-
-// Timezone (ISO-8601)
-export class ISOTimezoneParser extends Parser<number> {
-  priority = 10;
-
-  parse(dateString: string, token: string): ParseResult<number> {
-    switch (token) {
-      case 'x':
-        return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
-      case 'xx':
-        return parseTimezonePattern(timezonePatterns.basic, dateString);
-      case 'xxxx':
-        return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
-      case 'xxxxx':
-        return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
-      case 'xxx':
-      default:
-        return parseTimezonePattern(timezonePatterns.extended, dateString);
-    }
-  }
-
-  set<DateType extends Date>(date: DateType, flags: ParseFlags, value: number): DateType {
-    if (flags.timestampIsSet) return date;
-    return constructFrom(date, date.getTime() - getTimezoneOffsetInMilliseconds(date) - value);
-  }
-
-  incompatibleTokens = ['t', 'T', 'X'];
-}