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

package/src/date-fns/locale/_lib/buildMatchFn/index.ts

@@ -1,11 +1,5 @@
-import type { Quarter, Era, Day, Month } from "../../../types";
-import type {
-  LocaleUnitValue,
-  LocaleWidth,
-  LocaleDayPeriod,
-  MatchFn,
-  MatchValueCallback,
-} from "../../types";
+import type { Quarter, Era, Day, Month } from '../../../types';
+import type { LocaleUnitValue, LocaleWidth, LocaleDayPeriod, MatchFn, MatchValueCallback } from '../../types';
 
 export interface BuildMatchFnArgs<
   Result extends LocaleUnitValue,
@@ -16,10 +10,7 @@ export interface BuildMatchFnArgs<
   defaultMatchWidth: DefaultMatchWidth;
   parsePatterns: BuildMatchFnParsePatterns<Result, DefaultParseWidth>;
   defaultParseWidth: DefaultParseWidth;
-  valueCallback?: MatchValueCallback<
-    Result extends LocaleDayPeriod ? string : number,
-    Result
-  >;
+  valueCallback?: MatchValueCallback<Result extends LocaleDayPeriod ? string : number, Result>;
 }
 
 export type BuildMatchFnMatchPatterns<DefaultWidth extends LocaleWidth> = {
@@ -28,54 +19,33 @@ export type BuildMatchFnMatchPatterns<DefaultWidth extends LocaleWidth> = {
   [Width in DefaultWidth]: RegExp;
 };
 
-export type BuildMatchFnParsePatterns<
-  Value extends LocaleUnitValue,
-  DefaultWidth extends LocaleWidth,
-> = {
+export type BuildMatchFnParsePatterns<Value extends LocaleUnitValue, DefaultWidth extends LocaleWidth> = {
   [Width in LocaleWidth]?: ParsePattern<Value>;
 } & {
   [Width in DefaultWidth]: ParsePattern<Value>;
 };
 
-export type ParsePattern<Value extends LocaleUnitValue> =
-  Value extends LocaleDayPeriod
-    ? Record<LocaleDayPeriod, RegExp>
-    : Value extends Quarter
-      ? readonly [RegExp, RegExp, RegExp, RegExp]
-      : Value extends Era
-        ? readonly [RegExp, RegExp]
-        : Value extends Day
-          ? readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp]
-          : Value extends Month
-            ? readonly [
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-                RegExp,
-              ]
-            : never;
+export type ParsePattern<Value extends LocaleUnitValue> = Value extends LocaleDayPeriod
+  ? Record<LocaleDayPeriod, RegExp>
+  : Value extends Quarter
+    ? readonly [RegExp, RegExp, RegExp, RegExp]
+    : Value extends Era
+      ? readonly [RegExp, RegExp]
+      : Value extends Day
+        ? readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp]
+        : Value extends Month
+          ? readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp]
+          : never;
 
 export function buildMatchFn<
   Value extends LocaleUnitValue,
   DefaultMatchWidth extends LocaleWidth,
   DefaultParseWidth extends LocaleWidth,
->(
-  args: BuildMatchFnArgs<Value, DefaultMatchWidth, DefaultParseWidth>,
-): MatchFn<Value> {
+>(args: BuildMatchFnArgs<Value, DefaultMatchWidth, DefaultParseWidth>): MatchFn<Value> {
   return (string, options = {}) => {
     const width = options.width;
 
-    const matchPattern =
-      (width && args.matchPatterns[width]) ||
-      args.matchPatterns[args.defaultMatchWidth];
+    const matchPattern = (width && args.matchPatterns[width]) || args.matchPatterns[args.defaultMatchWidth];
     const matchResult = string.match(matchPattern);
 
     if (!matchResult) {
@@ -83,9 +53,7 @@ export function buildMatchFn<
     }
     const matchedString = matchResult[0];
 
-    const parsePatterns =
-      (width && args.parsePatterns[width]) ||
-      args.parsePatterns[args.defaultParseWidth];
+    const parsePatterns = (width && args.parsePatterns[width]) || args.parsePatterns[args.defaultParseWidth];
 
     const key = (
       Array.isArray(parsePatterns)
@@ -113,20 +81,14 @@ function findKey<Value, Obj extends { [key in string | number]: Value }>(
   predicate: (value: Value) => boolean,
 ): keyof Obj | undefined {
   for (const key in object) {
-    if (
-      Object.prototype.hasOwnProperty.call(object, key) &&
-      predicate(object[key]!)
-    ) {
+    if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key]!)) {
       return key;
     }
   }
   return undefined;
 }
 
-function findIndex<Item>(
-  array: Item[],
-  predicate: (item: Item) => boolean,
-): number | undefined {
+function findIndex<Item>(array: Item[], predicate: (item: Item) => boolean): number | undefined {
   for (let key = 0; key < array.length; key++) {
     if (predicate(array[key]!)) {
       return key;

package/src/date-fns/locale/_lib/buildMatchPatternFn/index.ts

@@ -1,4 +1,4 @@
-import type { MatchFn, MatchValueCallback } from "../../types";
+import type { MatchFn, MatchValueCallback } from '../../types';
 
 export interface BuildMatchPatternFnArgs<Result> {
   matchPattern: RegExp;
@@ -6,9 +6,7 @@ export interface BuildMatchPatternFnArgs<Result> {
   valueCallback?: MatchValueCallback<string, Result>;
 }
 
-export function buildMatchPatternFn<Result>(
-  args: BuildMatchPatternFnArgs<Result>,
-): MatchFn<Result> {
+export function buildMatchPatternFn<Result>(args: BuildMatchPatternFnArgs<Result>): MatchFn<Result> {
   return (string, options = {}) => {
     const matchResult = string.match(args.matchPattern);
     if (!matchResult) return null;
@@ -16,9 +14,7 @@ export function buildMatchPatternFn<Result>(
 
     const parseResult = string.match(args.parsePattern);
     if (!parseResult) return null;
-    let value = (
-      args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0]
-    ) as Result;
+    let value = (args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0]) as Result;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
     value = options.valueCallback ? options.valueCallback(value as any) : value;
 

package/src/date-fns/locale/en-US/_lib/formatDistance/index.ts

@@ -1,4 +1,4 @@
-import type { FormatDistanceFn, FormatDistanceLocale } from "../../../types";
+import type { FormatDistanceFn, FormatDistanceLocale } from '../../../types';
 
 type FormatDistanceTokenValue =
   | string
@@ -9,80 +9,80 @@ type FormatDistanceTokenValue =
 
 const formatDistanceLocale: FormatDistanceLocale<FormatDistanceTokenValue> = {
   lessThanXSeconds: {
-    one: "less than a second",
-    other: "less than {{count}} seconds",
+    one: 'less than a second',
+    other: 'less than {{count}} seconds',
   },
 
   xSeconds: {
-    one: "1 second",
-    other: "{{count}} seconds",
+    one: '1 second',
+    other: '{{count}} seconds',
   },
 
-  halfAMinute: "half a minute",
+  halfAMinute: 'half a minute',
 
   lessThanXMinutes: {
-    one: "less than a minute",
-    other: "less than {{count}} minutes",
+    one: 'less than a minute',
+    other: 'less than {{count}} minutes',
   },
 
   xMinutes: {
-    one: "1 minute",
-    other: "{{count}} minutes",
+    one: '1 minute',
+    other: '{{count}} minutes',
   },
 
   aboutXHours: {
-    one: "about 1 hour",
-    other: "about {{count}} hours",
+    one: 'about 1 hour',
+    other: 'about {{count}} hours',
   },
 
   xHours: {
-    one: "1 hour",
-    other: "{{count}} hours",
+    one: '1 hour',
+    other: '{{count}} hours',
   },
 
   xDays: {
-    one: "1 day",
-    other: "{{count}} days",
+    one: '1 day',
+    other: '{{count}} days',
   },
 
   aboutXWeeks: {
-    one: "about 1 week",
-    other: "about {{count}} weeks",
+    one: 'about 1 week',
+    other: 'about {{count}} weeks',
   },
 
   xWeeks: {
-    one: "1 week",
-    other: "{{count}} weeks",
+    one: '1 week',
+    other: '{{count}} weeks',
   },
 
   aboutXMonths: {
-    one: "about 1 month",
-    other: "about {{count}} months",
+    one: 'about 1 month',
+    other: 'about {{count}} months',
   },
 
   xMonths: {
-    one: "1 month",
-    other: "{{count}} months",
+    one: '1 month',
+    other: '{{count}} months',
   },
 
   aboutXYears: {
-    one: "about 1 year",
-    other: "about {{count}} years",
+    one: 'about 1 year',
+    other: 'about {{count}} years',
   },
 
   xYears: {
-    one: "1 year",
-    other: "{{count}} years",
+    one: '1 year',
+    other: '{{count}} years',
   },
 
   overXYears: {
-    one: "over 1 year",
-    other: "over {{count}} years",
+    one: 'over 1 year',
+    other: 'over {{count}} years',
   },
 
   almostXYears: {
-    one: "almost 1 year",
-    other: "almost {{count}} years",
+    one: 'almost 1 year',
+    other: 'almost {{count}} years',
   },
 };
 
@@ -90,19 +90,19 @@ export const formatDistance: FormatDistanceFn = (token, count, options) => {
   let result;
 
   const tokenValue = formatDistanceLocale[token];
-  if (typeof tokenValue === "string") {
+  if (typeof tokenValue === 'string') {
     result = tokenValue;
   } else if (count === 1) {
     result = tokenValue.one;
   } else {
-    result = tokenValue.other.replace("{{count}}", count.toString());
+    result = tokenValue.other.replace('{{count}}', count.toString());
   }
 
   if (options?.addSuffix) {
     if (options.comparison && options.comparison > 0) {
-      return "in " + result;
+      return 'in ' + result;
     } else {
-      return result + " ago";
+      return result + ' ago';
     }
   }
 

package/src/date-fns/locale/en-US/_lib/formatLong/index.ts

@@ -1,40 +1,40 @@
-import { buildFormatLongFn } from "../../../_lib/buildFormatLongFn/index";
-import type { FormatLong } from "../../../types";
+import { buildFormatLongFn } from '../../../_lib/buildFormatLongFn/index';
+import type { FormatLong } from '../../../types';
 
 const dateFormats = {
-  full: "EEEE, MMMM do, y",
-  long: "MMMM do, y",
-  medium: "MMM d, y",
-  short: "MM/dd/yyyy",
+  full: 'EEEE, MMMM do, y',
+  long: 'MMMM do, y',
+  medium: 'MMM d, y',
+  short: 'MM/dd/yyyy',
 };
 
 const timeFormats = {
-  full: "h:mm:ss a zzzz",
-  long: "h:mm:ss a z",
-  medium: "h:mm:ss a",
-  short: "h:mm a",
+  full: 'h:mm:ss a zzzz',
+  long: 'h:mm:ss a z',
+  medium: 'h:mm:ss a',
+  short: 'h:mm a',
 };
 
 const dateTimeFormats = {
   full: "{{date}} 'at' {{time}}",
   long: "{{date}} 'at' {{time}}",
-  medium: "{{date}}, {{time}}",
-  short: "{{date}}, {{time}}",
+  medium: '{{date}}, {{time}}',
+  short: '{{date}}, {{time}}',
 };
 
 export const formatLong: FormatLong = {
   date: buildFormatLongFn({
     formats: dateFormats,
-    defaultWidth: "full",
+    defaultWidth: 'full',
   }),
 
   time: buildFormatLongFn({
     formats: timeFormats,
-    defaultWidth: "full",
+    defaultWidth: 'full',
   }),
 
   dateTime: buildFormatLongFn({
     formats: dateTimeFormats,
-    defaultWidth: "full",
+    defaultWidth: 'full',
   }),
 };

package/src/date-fns/locale/en-US/_lib/formatRelative/index.ts

@@ -1,4 +1,4 @@
-import type { FormatRelativeFn } from "../../../types";
+import type { FormatRelativeFn } from '../../../types';
 
 const formatRelativeLocale = {
   lastWeek: "'last' eeee 'at' p",
@@ -6,12 +6,7 @@ const formatRelativeLocale = {
   today: "'today at' p",
   tomorrow: "'tomorrow at' p",
   nextWeek: "eeee 'at' p",
-  other: "P",
+  other: 'P',
 };
 
-export const formatRelative: FormatRelativeFn = (
-  token,
-  _date,
-  _baseDate,
-  _options,
-) => formatRelativeLocale[token];
+export const formatRelative: FormatRelativeFn = (token, _date, _baseDate, _options) => formatRelativeLocale[token];

package/src/date-fns/locale/en-US/_lib/localize/index.ts

@@ -1,16 +1,16 @@
-import type { Localize, LocalizeFn } from "../../../types";
-import { buildLocalizeFn } from "../../../_lib/buildLocalizeFn/index";
+import type { Localize, LocalizeFn } from '../../../types';
+import { buildLocalizeFn } from '../../../_lib/buildLocalizeFn/index';
 
 const eraValues = {
-  narrow: ["B", "A"] as const,
-  abbreviated: ["BC", "AD"] as const,
-  wide: ["Before Christ", "Anno Domini"] as const,
+  narrow: ['B', 'A'] as const,
+  abbreviated: ['BC', 'AD'] as const,
+  wide: ['Before Christ', 'Anno Domini'] as const,
 };
 
 const quarterValues = {
-  narrow: ["1", "2", "3", "4"] as const,
-  abbreviated: ["Q1", "Q2", "Q3", "Q4"] as const,
-  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"] as const,
+  narrow: ['1', '2', '3', '4'] as const,
+  abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'] as const,
+  wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter'] as const,
 };
 
 // Note: in English, the names of days of the week and months are capitalized.
@@ -18,115 +18,94 @@ const quarterValues = {
 // Generally, formatted dates should look like they are in the middle of a sentence,
 // e.g. in Spanish language the weekdays and months should be in the lowercase.
 const monthValues = {
-  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"] as const,
-  abbreviated: [
-    "Jan",
-    "Feb",
-    "Mar",
-    "Apr",
-    "May",
-    "Jun",
-    "Jul",
-    "Aug",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dec",
-  ] as const,
+  narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'] as const,
+  abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] as const,
   wide: [
-    "January",
-    "February",
-    "March",
-    "April",
-    "May",
-    "June",
-    "July",
-    "August",
-    "September",
-    "October",
-    "November",
-    "December",
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
   ] as const,
 };
 
 const dayValues = {
-  narrow: ["S", "M", "T", "W", "T", "F", "S"] as const,
-  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"] as const,
-  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const,
-  wide: [
-    "Sunday",
-    "Monday",
-    "Tuesday",
-    "Wednesday",
-    "Thursday",
-    "Friday",
-    "Saturday",
-  ] as const,
+  narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'] as const,
+  short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'] as const,
+  abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'] as const,
+  wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] as const,
 };
 
 const dayPeriodValues = {
   narrow: {
-    am: "a",
-    pm: "p",
-    midnight: "mi",
-    noon: "n",
-    morning: "morning",
-    afternoon: "afternoon",
-    evening: "evening",
-    night: "night",
+    am: 'a',
+    pm: 'p',
+    midnight: 'mi',
+    noon: 'n',
+    morning: 'morning',
+    afternoon: 'afternoon',
+    evening: 'evening',
+    night: 'night',
   },
   abbreviated: {
-    am: "AM",
-    pm: "PM",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "morning",
-    afternoon: "afternoon",
-    evening: "evening",
-    night: "night",
+    am: 'AM',
+    pm: 'PM',
+    midnight: 'midnight',
+    noon: 'noon',
+    morning: 'morning',
+    afternoon: 'afternoon',
+    evening: 'evening',
+    night: 'night',
   },
   wide: {
-    am: "a.m.",
-    pm: "p.m.",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "morning",
-    afternoon: "afternoon",
-    evening: "evening",
-    night: "night",
+    am: 'a.m.',
+    pm: 'p.m.',
+    midnight: 'midnight',
+    noon: 'noon',
+    morning: 'morning',
+    afternoon: 'afternoon',
+    evening: 'evening',
+    night: 'night',
   },
 };
 
 const formattingDayPeriodValues = {
   narrow: {
-    am: "a",
-    pm: "p",
-    midnight: "mi",
-    noon: "n",
-    morning: "in the morning",
-    afternoon: "in the afternoon",
-    evening: "in the evening",
-    night: "at night",
+    am: 'a',
+    pm: 'p',
+    midnight: 'mi',
+    noon: 'n',
+    morning: 'in the morning',
+    afternoon: 'in the afternoon',
+    evening: 'in the evening',
+    night: 'at night',
   },
   abbreviated: {
-    am: "AM",
-    pm: "PM",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "in the morning",
-    afternoon: "in the afternoon",
-    evening: "in the evening",
-    night: "at night",
+    am: 'AM',
+    pm: 'PM',
+    midnight: 'midnight',
+    noon: 'noon',
+    morning: 'in the morning',
+    afternoon: 'in the afternoon',
+    evening: 'in the evening',
+    night: 'at night',
   },
   wide: {
-    am: "a.m.",
-    pm: "p.m.",
-    midnight: "midnight",
-    noon: "noon",
-    morning: "in the morning",
-    afternoon: "in the afternoon",
-    evening: "in the evening",
-    night: "at night",
+    am: 'a.m.',
+    pm: 'p.m.',
+    midnight: 'midnight',
+    noon: 'noon',
+    morning: 'in the morning',
+    afternoon: 'in the afternoon',
+    evening: 'in the evening',
+    night: 'at night',
   },
 };
 
@@ -144,14 +123,14 @@ const ordinalNumber: LocalizeFn<number> = (dirtyNumber, _options) => {
   if (rem100 > 20 || rem100 < 10) {
     switch (rem100 % 10) {
       case 1:
-        return number + "st";
+        return number + 'st';
       case 2:
-        return number + "nd";
+        return number + 'nd';
       case 3:
-        return number + "rd";
+        return number + 'rd';
     }
   }
-  return number + "th";
+  return number + 'th';
 };
 
 export const localize: Localize = {
@@ -159,29 +138,29 @@ export const localize: Localize = {
 
   era: buildLocalizeFn({
     values: eraValues,
-    defaultWidth: "wide",
+    defaultWidth: 'wide',
   }),
 
   quarter: buildLocalizeFn({
     values: quarterValues,
-    defaultWidth: "wide",
+    defaultWidth: 'wide',
     argumentCallback: (quarter) => quarter - 1,
   }),
 
   month: buildLocalizeFn({
     values: monthValues,
-    defaultWidth: "wide",
+    defaultWidth: 'wide',
   }),
 
   day: buildLocalizeFn({
     values: dayValues,
-    defaultWidth: "wide",
+    defaultWidth: 'wide',
   }),
 
   dayPeriod: buildLocalizeFn({
     values: dayPeriodValues,
-    defaultWidth: "wide",
+    defaultWidth: 'wide',
     formattingValues: formattingDayPeriodValues,
-    defaultFormattingWidth: "wide",
+    defaultFormattingWidth: 'wide',
   }),
 };