@checkdigit/time 1.0.0-PR.11-7d2f

package/src/holidays/united-states/federal-reserve-bank/get-all-federal-reserve-bank-holidays.ts

@@ -0,0 +1,177 @@
+// holidays/united-states/federal-reserve-bank/get-all-federal-reserve-bank-holidays.ts
+
+import { formatUtc } from '../../../index';
+
+const YYYY_MM_DD_FORMAT = 'yyyy-MM-dd';
+
+const DAY_OF_THE_WEEK_SUNDAY = 0;
+const DAY_OF_THE_WEEK_MONDAY = 1;
+const DAY_OF_THE_WEEK_THURSDAY = 4;
+const DAY_OF_THE_WEEK_SATURDAY = 6;
+
+const MONTH_JANUARY = 0;
+const MONTH_FEBRUARY = 1;
+const MONTH_MAY = 4;
+const MONTH_JUNE = 5;
+const MONTH_JULY = 6;
+const MONTH_SEPTEMBER = 8;
+const MONTH_OCTOBER = 9;
+const MONTH_NOVEMBER = 10;
+const MONTH_DECEMBER = 11;
+
+const DATE_ONE = 1;
+const DATE_TWO = 2;
+const DATE_FOUR = 4;
+const DATE_FIVE = 5;
+const DATE_ELEVEN = 11;
+const DATE_TWELVE = 12;
+const DATE_NINETEEN = 19;
+const DATE_TWENTY = 20;
+const DATE_TWENTY_FIVE = 25;
+const DATE_TWENTY_SIX = 26;
+const DATE_THIRTY_ONE = 31;
+
+const OCCURRENCE_FIRST = 1;
+const OCCURRENCE_SECOND = 2;
+const OCCURRENCE_THIRD = 3;
+const OCCURRENCE_FOURTH = 4;
+
+const YEAR2021 = 2021;
+
+export interface FederalReserveBankHoliday {
+  name: string;
+  date: string;
+  observedOn?: string | undefined;
+}
+
+function getLastMondayOfMay(year: number) {
+  const lastDayOfMay = new Date(year, MONTH_MAY, DATE_THIRTY_ONE); // last day of may
+  const lastMondayOfMayDay =
+    lastDayOfMay.getDate() - (lastDayOfMay.getDay() - 1 < 1 ? DAY_OF_THE_WEEK_SATURDAY : lastDayOfMay.getDay() - 1);
+  return formatUtc(new Date(year, MONTH_MAY, lastMondayOfMayDay), YYYY_MM_DD_FORMAT);
+}
+
+function getNthOccurrenceOfDayOfTheWeekInMonth(nth: number, dayOfTheWeek: number, month: number, year: number) {
+  const date = new Date(year, month, DATE_ONE); // first day of the month
+  date.setDate(1 + ((7 - date.getDay() + dayOfTheWeek) % 7) + (nth - 1) * 7);
+  return formatUtc(date, YYYY_MM_DD_FORMAT);
+}
+
+export default function (year: number): FederalReserveBankHoliday[] {
+  const newYearsDay =
+    new Date(year, MONTH_JANUARY, DATE_ONE).getDay() === DAY_OF_THE_WEEK_SUNDAY
+      ? {
+          name: `New Year's Day`,
+          date: formatUtc(new Date(year, MONTH_JANUARY, DATE_ONE), YYYY_MM_DD_FORMAT),
+          observedOn: formatUtc(new Date(year, MONTH_JANUARY, DATE_TWO), YYYY_MM_DD_FORMAT),
+        }
+      : {
+          name: `New Year's Day`,
+          date: formatUtc(new Date(year, MONTH_JANUARY, DATE_ONE), YYYY_MM_DD_FORMAT),
+        };
+
+  const martinLutherKingJrDay = {
+    name: 'Birthday of Martin Luther King, Jr.',
+    date: getNthOccurrenceOfDayOfTheWeekInMonth(OCCURRENCE_THIRD, DAY_OF_THE_WEEK_MONDAY, MONTH_JANUARY, year), // Birthday of Martin Luther King, Jr. is the Third Monday of January
+  };
+
+  const washingtonsBirthday = {
+    name: `Washington's Birthday`,
+    date: getNthOccurrenceOfDayOfTheWeekInMonth(OCCURRENCE_THIRD, DAY_OF_THE_WEEK_MONDAY, MONTH_FEBRUARY, year), // Washington's Birthday is the Third Monday of February
+  };
+
+  const memorialDay = {
+    name: 'Memorial Day',
+    date: getLastMondayOfMay(year), // Memorial Day is the Last Monday of May
+  };
+
+  const juneteenth =
+    new Date(year, MONTH_JUNE, DATE_NINETEEN).getDay() === DAY_OF_THE_WEEK_SUNDAY
+      ? {
+          name: 'Juneteenth National Independence Day',
+          date: formatUtc(new Date(year, MONTH_JUNE, DATE_NINETEEN), YYYY_MM_DD_FORMAT),
+          observedOn: formatUtc(new Date(year, MONTH_JUNE, DATE_TWENTY), YYYY_MM_DD_FORMAT),
+        }
+      : {
+          name: 'Juneteenth National Independence Day',
+          date: formatUtc(new Date(year, MONTH_JUNE, DATE_NINETEEN), YYYY_MM_DD_FORMAT),
+        };
+
+  const independenceDay =
+    new Date(year, MONTH_JULY, DATE_FOUR).getDay() === DAY_OF_THE_WEEK_SUNDAY
+      ? {
+          name: 'Independence Day',
+          date: formatUtc(new Date(year, MONTH_JULY, DATE_FOUR), YYYY_MM_DD_FORMAT),
+          observedOn: formatUtc(new Date(year, MONTH_JULY, DATE_FIVE), YYYY_MM_DD_FORMAT),
+        }
+      : {
+          name: 'Independence Day',
+          date: formatUtc(new Date(year, MONTH_JULY, DATE_FOUR), YYYY_MM_DD_FORMAT),
+        };
+
+  const laborDay = {
+    name: 'Labor Day',
+    date: getNthOccurrenceOfDayOfTheWeekInMonth(OCCURRENCE_FIRST, DAY_OF_THE_WEEK_MONDAY, MONTH_SEPTEMBER, year), // Labor Day is the First Monday of September
+  };
+
+  const columbusDay = {
+    name: 'Columbus Day',
+    date: getNthOccurrenceOfDayOfTheWeekInMonth(OCCURRENCE_SECOND, DAY_OF_THE_WEEK_MONDAY, MONTH_OCTOBER, year), // Columbus Day is the Second Monday of October
+  };
+
+  const veteransDay =
+    new Date(year, MONTH_NOVEMBER, DATE_ELEVEN).getDay() === DAY_OF_THE_WEEK_SUNDAY
+      ? {
+          name: 'Veterans Day',
+          date: formatUtc(new Date(year, MONTH_NOVEMBER, DATE_ELEVEN), YYYY_MM_DD_FORMAT),
+          observedOn: formatUtc(new Date(year, MONTH_NOVEMBER, DATE_TWELVE), YYYY_MM_DD_FORMAT),
+        }
+      : {
+          name: 'Veterans Day',
+          date: formatUtc(new Date(year, MONTH_NOVEMBER, DATE_ELEVEN), YYYY_MM_DD_FORMAT),
+        };
+
+  const thanksGivingDay = {
+    name: 'Thanksgiving Day',
+    date: getNthOccurrenceOfDayOfTheWeekInMonth(OCCURRENCE_FOURTH, DAY_OF_THE_WEEK_THURSDAY, MONTH_NOVEMBER, year), // Thanksgiving Day is the Fourth Thursday of November
+  };
+
+  const christmasDay =
+    new Date(year, MONTH_DECEMBER, DATE_TWENTY_FIVE).getDay() === DAY_OF_THE_WEEK_SUNDAY
+      ? {
+          name: 'Christmas Day',
+          date: formatUtc(new Date(year, MONTH_DECEMBER, DATE_TWENTY_FIVE), YYYY_MM_DD_FORMAT),
+          observedOn: formatUtc(new Date(year, MONTH_DECEMBER, DATE_TWENTY_SIX), YYYY_MM_DD_FORMAT),
+        }
+      : {
+          name: 'Christmas Day',
+          date: formatUtc(new Date(year, MONTH_DECEMBER, DATE_TWENTY_FIVE), YYYY_MM_DD_FORMAT),
+        };
+
+  return year >= YEAR2021
+    ? [
+        newYearsDay,
+        martinLutherKingJrDay,
+        washingtonsBirthday,
+        memorialDay,
+        juneteenth,
+        independenceDay,
+        laborDay,
+        columbusDay,
+        veteransDay,
+        thanksGivingDay,
+        christmasDay,
+      ]
+    : [
+        newYearsDay,
+        martinLutherKingJrDay,
+        washingtonsBirthday,
+        memorialDay,
+        independenceDay,
+        laborDay,
+        columbusDay,
+        veteransDay,
+        thanksGivingDay,
+        christmasDay,
+      ];
+}

package/src/holidays/united-states/federal-reserve-bank/is-federal-reserve-bank-holiday.ts

@@ -0,0 +1,23 @@
+// holidays/united-states/federal-reserve-bank/is-federal-reserve-bank-holiday.ts
+
+import { formatUtc } from '../../../index';
+
+import getAllFederalReserveBankHolidays from './get-all-federal-reserve-bank-holidays';
+
+const DAY_OF_THE_WEEK_SUNDAY = 0;
+const DAY_OF_THE_WEEK_SATURDAY = 6;
+
+export default function (date: Date): boolean {
+  const year = date.getUTCFullYear();
+  const day = date.getUTCDay();
+  const allUsFederalReserveBankHolidays = getAllFederalReserveBankHolidays(year);
+
+  return (
+    day === DAY_OF_THE_WEEK_SATURDAY ||
+    day === DAY_OF_THE_WEEK_SUNDAY ||
+    allUsFederalReserveBankHolidays.some(
+      (holiday) =>
+        holiday.date === formatUtc(date, 'yyyy-MM-dd') || holiday.observedOn === formatUtc(date, 'yyyy-MM-dd')
+    )
+  );
+}

package/src/holidays/united-states/federal-reserve-bank/subtract-federal-reserve-bank-business-days.ts

@@ -0,0 +1,23 @@
+// holidays/united-states/federal-reserve-bank/subtract-federal-reserve-bank-business-days.ts
+
+import isFederalReserveBankHoliday from './is-federal-reserve-bank-holiday';
+
+export default function (date: Date, amount: number): Date {
+  if (Number.isNaN(amount)) {
+    throw new TypeError('Invalid Amount');
+  }
+
+  const endDate = new Date(date);
+
+  const hours = date.getUTCHours();
+  let count = 0;
+  while (count < amount) {
+    endDate.setUTCDate(endDate.getUTCDate() - 1);
+    if (!isFederalReserveBankHoliday(endDate)) {
+      count++;
+    }
+  }
+
+  endDate.setUTCHours(hours);
+  return endDate;
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+// index.ts
+
+export * as Temporal from './temporal';
+
+// export all date-fns functions
+export * from './date-fns';
+
+// export all date-fns-tz functions
+export * from './date-fns-tz';
+
+// export local date-fns-tz helper functions
+export { default as formatUtc } from './format-utc';

package/src/instant.ts

@@ -0,0 +1,120 @@
+// instant.ts
+
+export type ComparisonResult = -1 | 0 | 1;
+
+const YEAR_DIGITS = 4;
+
+const THOUSAND_DIGITS = 3;
+const MILLION_DIGITS = 6;
+const BILLION_DIGITS = 9;
+
+const THOUSAND = 10 ** THOUSAND_DIGITS;
+const MILLION = 10 ** MILLION_DIGITS;
+const BILLION = 10 ** BILLION_DIGITS;
+
+const extraRegEx = /\.\d\d\d(?<extra>\d+)Z$/u;
+
+/**
+ * Partial implementation of Temporal.Instant, part of the new TC39 Temporal proposal.
+ *
+ * See docs here: https://tc39.es/proposal-temporal/docs/instant.html
+ */
+export class Instant {
+  constructor(private readonly nanoseconds: bigint) {}
+
+  static fromEpochSeconds(epochSeconds: number): Instant {
+    return new Instant(BigInt(epochSeconds) * BigInt(BILLION));
+  }
+
+  static fromEpochMilliseconds(epochMilliseconds: number): Instant {
+    return new Instant(BigInt(BigInt(epochMilliseconds) * BigInt(MILLION)));
+  }
+
+  static fromEpochMicroseconds(epochMicroseconds: bigint): Instant {
+    return new Instant(BigInt(BigInt(epochMicroseconds) * BigInt(THOUSAND)));
+  }
+
+  static fromEpochNanoseconds(epochNanoseconds: bigint): Instant {
+    return new Instant(epochNanoseconds);
+  }
+
+  static from(item: Instant | string): Instant {
+    if (item instanceof Instant) {
+      return item;
+    }
+    const extra = extraRegEx.exec(item)?.groups?.['extra'] ?? '';
+    const extraDigits = BigInt(extra) * BigInt(10 ** (MILLION_DIGITS - extra.length));
+    const nanoseconds = BigInt(new Date(item).getTime()) * BigInt(MILLION) + extraDigits;
+    return new Instant(nanoseconds);
+  }
+
+  static compare(one: { epochNanoseconds: bigint }, two: { epochNanoseconds: bigint }): ComparisonResult {
+    if (one.epochNanoseconds > two.epochNanoseconds) {
+      return 1;
+    }
+    if (one.epochNanoseconds < two.epochNanoseconds) {
+      return -1;
+    }
+    return 0;
+  }
+
+  get epochSeconds(): number {
+    return Number(this.nanoseconds / BigInt(BILLION));
+  }
+
+  get epochMilliseconds(): number {
+    return Number(this.nanoseconds / BigInt(MILLION));
+  }
+
+  get epochMicroseconds(): bigint {
+    return this.nanoseconds / BigInt(THOUSAND);
+  }
+
+  get epochNanoseconds(): bigint {
+    return this.nanoseconds;
+  }
+
+  equals(this: Instant, other: Instant): boolean {
+    return this.nanoseconds === other.epochNanoseconds;
+  }
+
+  toString(this: Instant): string {
+    let nanoseconds = Number(this.nanoseconds % BigInt(BILLION));
+    const epochMilliseconds =
+      Number((this.nanoseconds / BigInt(BILLION)) * BigInt(THOUSAND)) + Math.floor(Number(nanoseconds / MILLION));
+    nanoseconds = Number((this.nanoseconds < BigInt(0) ? BILLION : 0) + nanoseconds);
+    const millisecond = Math.floor(nanoseconds / MILLION) % THOUSAND;
+    const microsecond = Math.floor(nanoseconds / THOUSAND) % THOUSAND;
+    const nanosecond = Math.floor(nanoseconds) % THOUSAND;
+
+    const item = new Date(epochMilliseconds);
+    const year = item.getUTCFullYear();
+    const month = item.getUTCMonth() + 1;
+    const day = item.getUTCDate();
+    const hour = item.getUTCHours();
+    const minute = item.getUTCMinutes();
+    const second = item.getUTCSeconds();
+
+    let fraction = `${millisecond * MILLION + microsecond * THOUSAND + nanosecond}`.padStart(BILLION_DIGITS, '0');
+    while (fraction[fraction.length - 1] === '0') {
+      fraction = fraction.slice(0, -1);
+    }
+    if (fraction.length > 0) {
+      fraction = `.${fraction}`;
+    }
+    return `${year.toString().padStart(YEAR_DIGITS, '0')}-${month.toString().padStart(2, '0')}-${day
+      .toString()
+      .padStart(2, '0')}T${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}:${second
+      .toString()
+      .padStart(2, '0')}${fraction}Z`;
+  }
+
+  toJSON(this: Instant): string {
+    return this.toString();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  valueOf(): never {
+    throw new TypeError('use compare() or equals() to compare Temporal.Instant');
+  }
+}

package/src/now.ts

@@ -0,0 +1,46 @@
+// now.ts
+
+import { Instant } from './instant';
+
+/**
+ * Partial implementation of Temporal.now, part of the new TC39 Temporal proposal.  Currently only instant() is
+ * supported.
+ *
+ * See docs here: https://tc39.es/proposal-temporal/docs/now.html
+ */
+
+const MILLION = 1e6;
+
+let baseDateTime = BigInt(Date.now());
+let baseHighResolutionTime = process.hrtime.bigint();
+let priorEpochNanoseconds = BigInt(0);
+
+/**
+ * This returns ever-increasing millisecond-accurate current time values in nanosecond form.
+ *
+ * To simulate nanosecond current time, we take the millisecond based clock and supplement with the HR timer.
+ * Two invocations within the same millisecond will have an accurate nanosecond difference between them, so
+ * this is useful for ensuring unique timestamps in webservices where concurrent execution may be an issue.
+ */
+export function instant(): Instant {
+  const dateTime = BigInt(Date.now());
+
+  if (dateTime > baseDateTime) {
+    // We're in a new millisecond, so reset the base HR time.
+    // This makes sure we're always returning a value that is consistent with the built-in millisecond clock.
+    baseHighResolutionTime = process.hrtime.bigint();
+    baseDateTime = dateTime;
+  }
+
+  let epochNanoseconds =
+    dateTime * BigInt(MILLION) + ((process.hrtime.bigint() - baseHighResolutionTime) % BigInt(MILLION));
+
+  if (epochNanoseconds < priorEpochNanoseconds) {
+    // the HR offset has overflowed, so reset the base HR time
+    baseHighResolutionTime = process.hrtime.bigint();
+    epochNanoseconds = priorEpochNanoseconds + ((process.hrtime.bigint() - baseHighResolutionTime) % BigInt(MILLION));
+  }
+
+  priorEpochNanoseconds = epochNanoseconds;
+  return new Instant(epochNanoseconds);
+}

package/src/temporal.ts

@@ -0,0 +1,4 @@
+// temporal.ts
+
+export * from './instant';
+export * as Now from './now';