@transferwise/components 0.0.0-experimental-fa3aa98 → 0.0.0-experimental-f4a328f

package/src/common/DateUtils/hasDisabledDatesInMonth/hasDisabledDatesInMonth.test.ts

@@ -1,98 +0,0 @@
-import { hasDisabledDatesInMonth } from './hasDisabledDatesInMonth';
-import type { DisabledRules } from '../../../Calendar/Calendar.types';
-
-describe('hasDisabledDatesInMonth', () => {
-  describe('weekdays', () => {
-    it('returns true when weekday rules exist (every month has all weekdays)', () => {
-      const rules: DisabledRules = { weekdays: ['sat', 'sun'], reason: 'Closed' };
-      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(true);
-    });
-
-    it('returns true for any month when weekday rules exist', () => {
-      const rules: DisabledRules = { weekdays: ['mon'], reason: 'Closed' };
-      expect(hasDisabledDatesInMonth(0, 2024, rules)).toBe(true);
-      expect(hasDisabledDatesInMonth(11, 2024, rules)).toBe(true);
-    });
-
-    it('returns false when weekdays array is empty', () => {
-      const rules: DisabledRules = { weekdays: [], reason: 'None' };
-      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(false);
-    });
-  });
-
-  describe('specific dates', () => {
-    const rules: DisabledRules = {
-      dates: [new Date(2024, 6, 11), new Date(2024, 6, 25), new Date(2025, 0, 1)],
-      reason: 'Bank holidays',
-    };
-
-    it('returns true when month contains a disabled date', () => {
-      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(true);
-    });
-
-    it('returns false when month has no disabled dates', () => {
-      expect(hasDisabledDatesInMonth(5, 2024, rules)).toBe(false);
-    });
-
-    it('returns true for another year with disabled date', () => {
-      expect(hasDisabledDatesInMonth(0, 2025, rules)).toBe(true);
-    });
-  });
-
-  describe('ranges', () => {
-    const rules: DisabledRules = {
-      ranges: [{ start: new Date(2024, 2, 29), end: new Date(2024, 3, 3) }],
-      reason: 'Maintenance',
-    };
-
-    it('returns true when range starts in the month', () => {
-      expect(hasDisabledDatesInMonth(2, 2024, rules)).toBe(true);
-    });
-
-    it('returns true when range ends in the month', () => {
-      expect(hasDisabledDatesInMonth(3, 2024, rules)).toBe(true);
-    });
-
-    it('returns true when range spans the entire month', () => {
-      const spanRules: DisabledRules = {
-        ranges: [{ start: new Date(2024, 0, 1), end: new Date(2024, 11, 31) }],
-        reason: 'Year-long',
-      };
-      expect(hasDisabledDatesInMonth(6, 2024, spanRules)).toBe(true);
-    });
-
-    it('returns false when range does not overlap the month', () => {
-      expect(hasDisabledDatesInMonth(4, 2024, rules)).toBe(false);
-    });
-  });
-
-  describe('min/max constraints', () => {
-    it('returns false when all disabled dates in month are outside min/max', () => {
-      const rules: DisabledRules = {
-        dates: [new Date(2024, 6, 1), new Date(2024, 6, 2)],
-        reason: 'Early',
-      };
-      const min = new Date(2024, 6, 10);
-      const max = new Date(2024, 6, 31);
-      expect(hasDisabledDatesInMonth(6, 2024, rules, min, max)).toBe(false);
-    });
-
-    it('returns true when weekdays exist regardless of min/max', () => {
-      const rules: DisabledRules = { weekdays: ['sat'], reason: 'Closed' };
-      const min = new Date(2024, 6, 10);
-      const max = new Date(2024, 6, 20);
-      expect(hasDisabledDatesInMonth(6, 2024, rules, min, max)).toBe(true);
-    });
-  });
-
-  describe('no rules', () => {
-    it('returns false when disabledRules is undefined', () => {
-      expect(hasDisabledDatesInMonth(6, 2024, undefined)).toBe(false);
-    });
-
-    it('returns false when only reason is provided', () => {
-      const rules: DisabledRules = { reason: 'Reason only' };
-      expect(hasDisabledDatesInMonth(6, 2024, rules)).toBe(false);
-    });
-  });
-});

package/src/common/DateUtils/hasDisabledDatesInMonth/hasDisabledDatesInMonth.ts

@@ -1,45 +0,0 @@
-import type { DisabledRules } from '../../../Calendar/Calendar.types';
-
-export function hasDisabledDatesInMonth(
-  month: number,
-  year: number,
-  disabledRules?: DisabledRules,
-  min?: Date | null,
-  max?: Date | null,
-): boolean {
-  if (!disabledRules) return false;
-
-  if (disabledRules.weekdays?.length) {
-    return true;
-  }
-
-  const monthStart = new Date(year, month, 1);
-  const monthEnd = new Date(year, month + 1, 0);
-
-  if (disabledRules.dates?.length) {
-    const hasDateInMonth = disabledRules.dates.some((date) => {
-      if (date.getFullYear() !== year || date.getMonth() !== month) return false;
-      if (min && date < min) return false;
-      if (max && date > max) return false;
-      return true;
-    });
-    if (hasDateInMonth) return true;
-  }
-
-  if (disabledRules.ranges?.length) {
-    const hasOverlap = disabledRules.ranges.some((range) => {
-      const rangeStart = new Date(
-        range.start.getFullYear(),
-        range.start.getMonth(),
-        range.start.getDate(),
-      );
-      const rangeEnd = new Date(range.end.getFullYear(), range.end.getMonth(), range.end.getDate());
-      if (max && rangeStart > max) return false;
-      if (min && rangeEnd < min) return false;
-      return rangeStart <= monthEnd && rangeEnd >= monthStart;
-    });
-    if (hasOverlap) return true;
-  }
-
-  return false;
-}

package/src/common/DateUtils/isDateDisabled/isDateDisabled.test.ts

@@ -1,169 +0,0 @@
-import { isDateDisabled } from './isDateDisabled';
-import type { DisabledRules } from '../../../Calendar/Calendar.types';
-
-describe('isDateDisabled', () => {
-  describe('when no rules provided', () => {
-    it('returns false when disabledRules is undefined', () => {
-      expect(isDateDisabled(new Date('2024-07-15'), undefined)).toBe(false);
-    });
-
-    it('returns false when disabledRules has only reason', () => {
-      const rules: DisabledRules = { reason: 'some reason' };
-      expect(isDateDisabled(new Date('2024-07-15'), rules)).toBe(false);
-    });
-  });
-
-  describe('weekdays', () => {
-    const rules: DisabledRules = {
-      weekdays: ['sat', 'sun'],
-      reason: 'Closed on weekends',
-    };
-
-    it('returns true for a Saturday', () => {
-      // 2024-07-13 is a Saturday
-      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(true);
-    });
-
-    it('returns true for a Sunday', () => {
-      // 2024-07-14 is a Sunday
-      expect(isDateDisabled(new Date(2024, 6, 14), rules)).toBe(true);
-    });
-
-    it('returns false for a Monday', () => {
-      // 2024-07-15 is a Monday
-      expect(isDateDisabled(new Date(2024, 6, 15), rules)).toBe(false);
-    });
-
-    it('returns false for a Friday', () => {
-      // 2024-07-12 is a Friday
-      expect(isDateDisabled(new Date(2024, 6, 12), rules)).toBe(false);
-    });
-
-    it('handles single weekday rule', () => {
-      const singleDay: DisabledRules = { weekdays: ['wed'], reason: 'Closed' };
-      // 2024-07-17 is a Wednesday
-      expect(isDateDisabled(new Date(2024, 6, 17), singleDay)).toBe(true);
-      // 2024-07-18 is a Thursday
-      expect(isDateDisabled(new Date(2024, 6, 18), singleDay)).toBe(false);
-    });
-  });
-
-  describe('specific dates', () => {
-    const rules: DisabledRules = {
-      dates: [new Date(2024, 6, 11), new Date(2025, 1, 12), new Date(2025, 4, 1)],
-      reason: 'Bank holidays',
-    };
-
-    it('returns true for a disabled date', () => {
-      expect(isDateDisabled(new Date(2024, 6, 11), rules)).toBe(true);
-    });
-
-    it('returns false for a non-disabled date', () => {
-      expect(isDateDisabled(new Date(2024, 6, 12), rules)).toBe(false);
-    });
-
-    it('compares date-only, ignoring time', () => {
-      const dateWithTime = new Date(2024, 6, 11, 14, 30, 0);
-      expect(isDateDisabled(dateWithTime, rules)).toBe(true);
-    });
-
-    it('handles disabled dates that have non-zero time components', () => {
-      const rulesWithTime: DisabledRules = {
-        dates: [new Date(2024, 6, 11, 23, 59, 59)],
-        reason: 'Holiday',
-      };
-      expect(isDateDisabled(new Date(2024, 6, 11), rulesWithTime)).toBe(true);
-    });
-  });
-
-  describe('ranges', () => {
-    const rules: DisabledRules = {
-      ranges: [
-        { start: new Date(2024, 2, 29), end: new Date(2024, 3, 3) },
-        { start: new Date(2024, 11, 24), end: new Date(2024, 11, 26) },
-      ],
-      reason: 'Scheduled maintenance',
-    };
-
-    it('returns true for start of range (inclusive)', () => {
-      expect(isDateDisabled(new Date(2024, 2, 29), rules)).toBe(true);
-    });
-
-    it('returns true for end of range (inclusive)', () => {
-      expect(isDateDisabled(new Date(2024, 3, 3), rules)).toBe(true);
-    });
-
-    it('returns true for date within range', () => {
-      expect(isDateDisabled(new Date(2024, 2, 31), rules)).toBe(true);
-    });
-
-    it('returns false for date before range', () => {
-      expect(isDateDisabled(new Date(2024, 2, 28), rules)).toBe(false);
-    });
-
-    it('returns false for date after range', () => {
-      expect(isDateDisabled(new Date(2024, 3, 4), rules)).toBe(false);
-    });
-
-    it('handles second range', () => {
-      expect(isDateDisabled(new Date(2024, 11, 25), rules)).toBe(true);
-      expect(isDateDisabled(new Date(2024, 11, 27), rules)).toBe(false);
-    });
-
-    it('correctly checks a date with non-midnight time against a range', () => {
-      const dateWithTime = new Date(2024, 2, 31, 14, 30, 0);
-      expect(isDateDisabled(dateWithTime, rules)).toBe(true);
-    });
-
-    it('correctly excludes a date with non-midnight time outside a range', () => {
-      const dateWithTime = new Date(2024, 2, 28, 23, 59, 59);
-      expect(isDateDisabled(dateWithTime, rules)).toBe(false);
-    });
-  });
-
-  describe('combined rules (additive)', () => {
-    const rules: DisabledRules = {
-      weekdays: ['sat', 'sun'],
-      dates: [new Date(2024, 6, 15)], // Monday
-      ranges: [{ start: new Date(2024, 6, 22), end: new Date(2024, 6, 24) }],
-      reason: 'Multiple rules',
-    };
-
-    it('disables by weekday', () => {
-      // 2024-07-13 is Saturday
-      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(true);
-    });
-
-    it('disables by specific date', () => {
-      // 2024-07-15 is Monday but explicitly disabled
-      expect(isDateDisabled(new Date(2024, 6, 15), rules)).toBe(true);
-    });
-
-    it('disables by range', () => {
-      // 2024-07-23 is Tuesday but in range
-      expect(isDateDisabled(new Date(2024, 6, 23), rules)).toBe(true);
-    });
-
-    it('allows date not matching any rule', () => {
-      // 2024-07-16 is Tuesday, not in dates or ranges
-      expect(isDateDisabled(new Date(2024, 6, 16), rules)).toBe(false);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('handles empty weekdays array', () => {
-      const rules: DisabledRules = { weekdays: [], reason: 'Empty' };
-      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(false);
-    });
-
-    it('handles empty dates array', () => {
-      const rules: DisabledRules = { dates: [], reason: 'Empty' };
-      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(false);
-    });
-
-    it('handles empty ranges array', () => {
-      const rules: DisabledRules = { ranges: [], reason: 'Empty' };
-      expect(isDateDisabled(new Date(2024, 6, 13), rules)).toBe(false);
-    });
-  });
-});

package/src/common/DateUtils/isDateDisabled/isDateDisabled.ts

@@ -1,59 +0,0 @@
-import type { DisabledRules, WeekDayType } from '../../../Calendar/Calendar.types';
-
-const DAY_INDEX_TO_WEEKDAY: Record<number, WeekDayType> = {
-  0: 'sun',
-  1: 'mon',
-  2: 'tue',
-  3: 'wed',
-  4: 'thu',
-  5: 'fri',
-  6: 'sat',
-};
-
-export function isDateDisabled(date: Date, disabledRules?: DisabledRules): boolean {
-  if (!disabledRules) return false;
-
-  if (disabledRules.weekdays?.length) {
-    const weekday = DAY_INDEX_TO_WEEKDAY[date.getDay()];
-    if (disabledRules.weekdays.includes(weekday)) return true;
-  }
-
-  if (disabledRules.dates?.length) {
-    const year = date.getFullYear();
-    const month = date.getMonth();
-    const day = date.getDate();
-    if (
-      disabledRules.dates.some(
-        (disabledDate) =>
-          disabledDate.getFullYear() === year &&
-          disabledDate.getMonth() === month &&
-          disabledDate.getDate() === day,
-      )
-    ) {
-      return true;
-    }
-  }
-
-  if (disabledRules.ranges?.length) {
-    const dateStart = date.getTime();
-    if (
-      disabledRules.ranges.some((range) => {
-        const rangeStart = new Date(
-          range.start.getFullYear(),
-          range.start.getMonth(),
-          range.start.getDate(),
-        ).getTime();
-        const rangeEnd = new Date(
-          range.end.getFullYear(),
-          range.end.getMonth(),
-          range.end.getDate(),
-        ).getTime();
-        return dateStart >= rangeStart && dateStart <= rangeEnd;
-      })
-    ) {
-      return true;
-    }
-  }
-
-  return false;
-}