@checkdigit/time 1.1.0 → 2.0.0-PR.14-c36c

package/src/date-fns/lastDayOfISOWeekYear/index.ts

@@ -0,0 +1,33 @@
+import getISOWeekYear from '../getISOWeekYear/index';
+import startOfISOWeek from '../startOfISOWeek/index';
+import constructFrom from '../constructFrom/index';
+
+/**
+ * @name lastDayOfISOWeekYear
+ * @category ISO Week-Numbering Year Helpers
+ * @summary Return the last day of an ISO week-numbering year for the given date.
+ *
+ * @description
+ * Return the last day of an ISO week-numbering year,
+ * which always starts 3 days before the year's first Thursday.
+ * The result will be in the local timezone.
+ *
+ * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+ *
+ * @param date - the original date
+ * @returns the end of an ISO week-numbering year
+ *
+ * @example
+ * // The last day of an ISO week-numbering year for 2 July 2005:
+ * const result = lastDayOfISOWeekYear(new Date(2005, 6, 2))
+ * //=> Sun Jan 01 2006 00:00:00
+ */
+export default function lastDayOfISOWeekYear<DateType extends Date>(dirtyDate: DateType | number): DateType {
+  const year = getISOWeekYear(dirtyDate);
+  const fourthOfJanuary = constructFrom(dirtyDate, 0);
+  fourthOfJanuary.setFullYear(year + 1, 0, 4);
+  fourthOfJanuary.setHours(0, 0, 0, 0);
+  const date = startOfISOWeek(fourthOfJanuary);
+  date.setDate(date.getDate() - 1);
+  return date;
+}

package/src/date-fns/lastDayOfMonth/index.ts

@@ -0,0 +1,26 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name lastDayOfMonth
+ * @category Month Helpers
+ * @summary Return the last day of a month for the given date.
+ *
+ * @description
+ * Return the last day of a month for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param date - the original date
+ * @returns the last day of a month
+ *
+ * @example
+ * // The last day of a month for 2 September 2014 11:55:00:
+ * const result = lastDayOfMonth(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Tue Sep 30 2014 00:00:00
+ */
+export default function lastDayOfMonth<DateType extends Date>(dirtyDate: DateType | number): DateType {
+  const date = toDate(dirtyDate);
+  const month = date.getMonth();
+  date.setFullYear(date.getFullYear(), month + 1, 0);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}

package/src/date-fns/lastDayOfQuarter/index.ts

@@ -0,0 +1,27 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name lastDayOfQuarter
+ * @category Quarter Helpers
+ * @summary Return the last day of a year quarter for the given date.
+ *
+ * @description
+ * Return the last day of a year quarter for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param date - the original date
+ * @returns the last day of a quarter
+ *
+ * @example
+ * // The last day of a quarter for 2 September 2014 11:55:00:
+ * const result = lastDayOfQuarter(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Tue Sep 30 2014 00:00:00
+ */
+export default function lastDayOfQuarter<DateType extends Date>(dirtyDate: DateType | number): DateType {
+  const date = toDate(dirtyDate);
+  const currentMonth = date.getMonth();
+  const month = currentMonth - (currentMonth % 3) + 3;
+  date.setMonth(month, 0);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}

package/src/date-fns/lastDayOfWeek/index.ts

@@ -0,0 +1,52 @@
+import toDate from '../toDate/index';
+import type { LocaleOptions, WeekStartOptions } from '../types';
+import { getDefaultOptions } from '../_lib/defaultOptions/index';
+
+/**
+ * The {@link lastDayOfWeek} function options.
+ */
+export interface LastDayOfWeekOptions extends LocaleOptions, WeekStartOptions {}
+
+/**
+ * @name lastDayOfWeek
+ * @category Week Helpers
+ * @summary Return the last day of a week for the given date.
+ *
+ * @description
+ * Return the last day of a week for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param date - the original date
+ * @param options - an object with options.
+ * @returns the last day of a week
+ *
+ * @example
+ * // The last day of a week for 2 September 2014 11:55:00:
+ * const result = lastDayOfWeek(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Sat Sep 06 2014 00:00:00
+ *
+ * @example
+ * // If the week starts on Monday, the last day of the week for 2 September 2014 11:55:00:
+ * const result = lastDayOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
+ * //=> Sun Sep 07 2014 00:00:00
+ */
+export default function lastDayOfWeek<DateType extends Date>(
+  dirtyDate: DateType | number,
+  options?: LastDayOfWeekOptions,
+): DateType {
+  const defaultOptions = getDefaultOptions();
+  const weekStartsOn =
+    options?.weekStartsOn ??
+    options?.locale?.options?.weekStartsOn ??
+    defaultOptions.weekStartsOn ??
+    defaultOptions.locale?.options?.weekStartsOn ??
+    0;
+
+  const date = toDate(dirtyDate);
+  const day = date.getDay();
+  const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
+
+  date.setHours(0, 0, 0, 0);
+  date.setDate(date.getDate() + diff);
+  return date;
+}

package/src/date-fns/lastDayOfYear/index.ts

@@ -0,0 +1,26 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name lastDayOfYear
+ * @category Year Helpers
+ * @summary Return the last day of a year for the given date.
+ *
+ * @description
+ * Return the last day of a year for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param date - the original date
+ * @returns the last day of a year
+ *
+ * @example
+ * // The last day of a year for 2 September 2014 11:55:00:
+ * const result = lastDayOfYear(new Date(2014, 8, 2, 11, 55, 00))
+ * //=> Wed Dec 31 2014 00:00:00
+ */
+export default function lastDayOfYear<DateType extends Date>(dirtyDate: DateType | number): DateType {
+  const date = toDate(dirtyDate);
+  const year = date.getFullYear();
+  date.setFullYear(year + 1, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}

package/src/date-fns/lightFormat/index.ts

@@ -0,0 +1,125 @@
+import isValid from '../isValid/index';
+import toDate from '../toDate/index';
+import formatters from '../_lib/format/lightFormatters/index';
+
+// This RegExp consists of three parts separated by `|`:
+// - (\w)\1* matches any sequences of the same letter
+// - '' matches two quote characters in a row
+// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
+//   except a single quote symbol, which ends the sequence.
+//   Two quote characters do not end the sequence.
+//   If there is no matching single quote
+//   then the sequence will continue until the end of the string.
+// - . matches any single character unmatched by previous parts of the RegExps
+const formattingTokensRegExp = /(\w)\1*|''|'(''|[^'])+('|$)|./g;
+
+const escapedStringRegExp = /^'([^]*?)'?$/;
+const doubleQuoteRegExp = /''/g;
+const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+
+/**
+ * @name lightFormat
+ * @category Common Helpers
+ * @summary Format the date.
+ *
+ * @description
+ * Return the formatted date string in the given format. Unlike `format`,
+ * `lightFormat` doesn't use locales and outputs date using the most popular tokens.
+ *
+ * > ⚠️ Please note that the `lightFormat` tokens differ from Moment.js and other libraries.
+ * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+ *
+ * The characters wrapped between two single quotes characters (') are escaped.
+ * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
+ *
+ * Format of the string is based on Unicode Technical Standard #35:
+ * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ *
+ * Accepted patterns:
+ * | Unit                            | Pattern | Result examples                   |
+ * |---------------------------------|---------|-----------------------------------|
+ * | AM, PM                          | a..aaa  | AM, PM                            |
+ * |                                 | aaaa    | a.m., p.m.                        |
+ * |                                 | aaaaa   | a, p                              |
+ * | Calendar year                   | y       | 44, 1, 1900, 2017                 |
+ * |                                 | yy      | 44, 01, 00, 17                    |
+ * |                                 | yyy     | 044, 001, 000, 017                |
+ * |                                 | yyyy    | 0044, 0001, 1900, 2017            |
+ * | Month (formatting)              | M       | 1, 2, ..., 12                     |
+ * |                                 | MM      | 01, 02, ..., 12                   |
+ * | Day of month                    | d       | 1, 2, ..., 31                     |
+ * |                                 | dd      | 01, 02, ..., 31                   |
+ * | Hour [1-12]                     | h       | 1, 2, ..., 11, 12                 |
+ * |                                 | hh      | 01, 02, ..., 11, 12               |
+ * | Hour [0-23]                     | H       | 0, 1, 2, ..., 23                  |
+ * |                                 | HH      | 00, 01, 02, ..., 23               |
+ * | Minute                          | m       | 0, 1, ..., 59                     |
+ * |                                 | mm      | 00, 01, ..., 59                   |
+ * | Second                          | s       | 0, 1, ..., 59                     |
+ * |                                 | ss      | 00, 01, ..., 59                   |
+ * | Fraction of second              | S       | 0, 1, ..., 9                      |
+ * |                                 | SS      | 00, 01, ..., 99                   |
+ * |                                 | SSS     | 000, 001, ..., 999                |
+ * |                                 | SSSS    | ...                               |
+ *
+ * @param date - the original date
+ * @param format - the string of tokens
+ * @returns the formatted date string
+ * @throws {RangeError} format string contains an unescaped latin alphabet character
+ *
+ * @example
+ * const result = lightFormat(new Date(2014, 1, 11), 'yyyy-MM-dd')
+ * //=> '2014-02-11'
+ */
+
+type Token = keyof typeof formatters;
+
+export default function lightFormat<DateType extends Date>(dirtyDate: DateType | number, formatStr: string): string {
+  const originalDate = toDate(dirtyDate);
+
+  if (!isValid(originalDate)) {
+    throw new RangeError('Invalid time value');
+  }
+
+  const tokens = formatStr.match(formattingTokensRegExp);
+
+  // The only case when formattingTokensRegExp doesn't match the string is when it's empty
+  if (!tokens) return '';
+
+  const result = tokens
+    .map((substring) => {
+      // Replace two single quote characters with one single quote character
+      if (substring === "''") {
+        return "'";
+      }
+
+      const firstCharacter = substring[0];
+      if (firstCharacter === "'") {
+        return cleanEscapedString(substring);
+      }
+
+      const formatter = formatters[firstCharacter as Token];
+      if (formatter) {
+        return formatter(originalDate, substring);
+      }
+
+      if (firstCharacter?.match(unescapedLatinCharacterRegExp)) {
+        throw new RangeError('Format string contains an unescaped latin alphabet character `' + firstCharacter + '`');
+      }
+
+      return substring;
+    })
+    .join('');
+
+  return result;
+}
+
+function cleanEscapedString(input: string): string {
+  const matches = input.match(escapedStringRegExp);
+
+  if (!matches) {
+    return input;
+  }
+
+  return matches[1]?.replace(doubleQuoteRegExp, "'") as string;
+}

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

@@ -0,0 +1,17 @@
+import type { FormatLongFn, FormatLongWidth } from '../../types';
+
+export interface BuildFormatLongFnArgs<DefaultMatchWidth extends FormatLongWidth> {
+  formats: Partial<{ [format in FormatLongWidth]: string }> & { [format in DefaultMatchWidth]: string };
+  defaultWidth: DefaultMatchWidth;
+}
+
+export default function buildFormatLongFn<DefaultMatchWidth extends FormatLongWidth>(
+  args: BuildFormatLongFnArgs<DefaultMatchWidth>,
+): FormatLongFn {
+  return (options = {}) => {
+    // TODO: Remove String()
+    const width = options.width ? (String(options.width) as FormatLongWidth) : args.defaultWidth;
+    const format = args.formats[width] || args.formats[args.defaultWidth];
+    return format;
+  };
+}

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

@@ -0,0 +1,97 @@
+import type { Era, Quarter, Month, Day } from '../../../types';
+import type { LocaleDayPeriod, LocalePatternWidth, LocaleUnit, LocalizeFn, LocalizeUnitIndex } from '../../types';
+
+type LocalizeEraValues = readonly [string, string];
+
+type LocalizeQuarterValues = readonly [string, string, string, string];
+
+type LocalizeDayValues = readonly [string, string, string, string, string, string, string];
+
+type LocalizeMonthValues = readonly [
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+];
+
+export type LocalizeUnitValuesIndex<Values extends LocalizeUnitValues<any>> = Values extends Record<
+  LocaleDayPeriod,
+  string
+>
+  ? string
+  : Values extends LocalizeEraValues
+  ? Era
+  : Values extends LocalizeQuarterValues
+  ? Quarter
+  : Values extends LocalizeDayValues
+  ? Day
+  : Values extends LocalizeMonthValues
+  ? Month
+  : never;
+
+export type LocalizeUnitValues<Unit extends LocaleUnit> = Unit extends LocaleDayPeriod
+  ? Record<LocaleDayPeriod, string>
+  : Unit extends Era
+  ? LocalizeEraValues
+  : Unit extends Quarter
+  ? LocalizeQuarterValues
+  : Unit extends Day
+  ? LocalizeDayValues
+  : Unit extends Month
+  ? LocalizeMonthValues
+  : never;
+
+export type LocalizePeriodValuesMap<Unit extends LocaleUnit> = {
+  [pattern in LocalePatternWidth]?: LocalizeUnitValues<Unit>;
+};
+
+export type BuildLocalizeFnArgCallback<Result extends LocaleUnit | number> = (
+  value: Result,
+) => LocalizeUnitIndex<Result>;
+
+export type BuildLocalizeFnArgs<
+  Result extends LocaleUnit,
+  ArgCallback extends BuildLocalizeFnArgCallback<Result> | undefined,
+> = {
+  values: LocalizePeriodValuesMap<Result>;
+  defaultWidth: LocalePatternWidth;
+  formattingValues?: LocalizePeriodValuesMap<Result>;
+  defaultFormattingWidth?: LocalePatternWidth;
+} & (ArgCallback extends undefined
+  ? { argumentCallback?: undefined }
+  : { argumentCallback: BuildLocalizeFnArgCallback<Result> });
+
+export default function buildLocalizeFn<
+  Result extends LocaleUnit,
+  ArgCallback extends BuildLocalizeFnArgCallback<Result> | undefined,
+>(args: BuildLocalizeFnArgs<Result, ArgCallback>): LocalizeFn<Result, ArgCallback> {
+  return (dirtyIndex, options) => {
+    const context = options?.context ? String(options.context) : 'standalone';
+
+    let valuesArray: LocalizeUnitValues<Result>;
+    if (context === 'formatting' && args.formattingValues) {
+      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      const width = (options?.width ? String(options.width) : defaultWidth) as LocalePatternWidth;
+      valuesArray = (args.formattingValues[width] || args.formattingValues[defaultWidth]) as LocalizeUnitValues<Result>;
+    } else {
+      const defaultWidth = args.defaultWidth;
+      const width = (options?.width ? String(options.width) : args.defaultWidth) as LocalePatternWidth;
+      valuesArray = (args.values[width] || args.values[defaultWidth]) as LocalizeUnitValues<Result>;
+    }
+    const index = (
+      args.argumentCallback
+        ? args.argumentCallback(dirtyIndex as Result)
+        : (dirtyIndex as LocalizeUnitIndex<Result> as unknown)
+    ) as LocalizeUnitValuesIndex<typeof valuesArray>;
+    // @ts-ignore: For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+    return valuesArray[index];
+  };
+}

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

@@ -0,0 +1,57 @@
+import type { BuildMatchFnArgs, LocaleDayPeriod, LocaleUnit, LocalePatternWidth, MatchFn } from '../../types';
+
+export default function buildMatchFn<
+  Result extends LocaleUnit,
+  DefaultMatchWidth extends LocalePatternWidth,
+  DefaultParseWidth extends LocalePatternWidth,
+>(args: BuildMatchFnArgs<Result, DefaultMatchWidth, DefaultParseWidth>): MatchFn<Result> {
+  return (string, options = {}) => {
+    const width = options.width;
+
+    const matchPattern = (width && args.matchPatterns[width]) || args.matchPatterns[args.defaultMatchWidth];
+    const matchResult = string.match(matchPattern);
+
+    if (!matchResult) {
+      return null;
+    }
+    const matchedString = matchResult[0];
+
+    const parsePatterns = (width && args.parsePatterns[width]) || args.parsePatterns[args.defaultParseWidth];
+
+    const key = (
+      Array.isArray(parsePatterns)
+        ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
+        : findKey(parsePatterns, (pattern: any) => pattern.test(matchedString))
+    ) as Result extends LocaleDayPeriod ? string : number;
+
+    let value: Result;
+
+    value = (args.valueCallback ? args.valueCallback(key) : key) as Result;
+    value = options.valueCallback ? options.valueCallback(value as any) : value;
+
+    const rest = string.slice((matchedString as string).length);
+
+    return { value, rest };
+  };
+}
+
+function findKey<Value, Obj extends { [key in string | number]: Value }>(
+  object: Obj,
+  predicate: (value: Value) => boolean,
+): keyof Obj | undefined {
+  for (const key in object) {
+    if (object.hasOwnProperty(key) && predicate(object[key] as Value)) {
+      return key;
+    }
+  }
+  return undefined;
+}
+
+function findIndex<Item>(array: Item[], predicate: (item: Item) => boolean): number | undefined {
+  for (let key = 0; key < array.length; key++) {
+    if (predicate(array[key] as Item)) {
+      return key;
+    }
+  }
+  return undefined;
+}

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

@@ -0,0 +1,24 @@
+import type { MatchFn, MatchValueCallback } from '../../types';
+
+export interface BuildMatchPatternFnArgs<Result> {
+  matchPattern: RegExp;
+  parsePattern: RegExp;
+  valueCallback?: MatchValueCallback<string, Result>;
+}
+
+export default function buildMatchPatternFn<Result>(args: BuildMatchPatternFnArgs<Result>): MatchFn<Result> {
+  return (string, options = {}) => {
+    const matchResult = string.match(args.matchPattern);
+    if (!matchResult) return null;
+    const matchedString = matchResult[0];
+
+    const parseResult = string.match(args.parsePattern);
+    if (!parseResult) return null;
+    let value = (args.valueCallback ? args.valueCallback(parseResult[0] as string) : parseResult[0]) as Result;
+    value = options.valueCallback ? options.valueCallback(value as any) : value;
+
+    const rest = string.slice((matchedString as string).length);
+
+    return { value, rest };
+  };
+}

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

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

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

@@ -0,0 +1,42 @@
+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',
+};
+
+const timeFormats = {
+  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}}',
+};
+
+const formatLong: FormatLong = {
+  date: buildFormatLongFn({
+    formats: dateFormats,
+    defaultWidth: 'full',
+  }),
+
+  time: buildFormatLongFn({
+    formats: timeFormats,
+    defaultWidth: 'full',
+  }),
+
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats,
+    defaultWidth: 'full',
+  }),
+};
+
+export default formatLong;

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

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