react-day-picker 9.6.2 → 9.6.3

package/src/utils/rangeOverlaps.ts

@@ -0,0 +1,22 @@
+import { defaultDateLib } from "../classes/index.js";
+
+import { rangeIncludesDate } from "./rangeIncludesDate.js";
+
+/**
+ * Determines whether a given range overlaps with another range.
+ *
+ * @since 9.2.2
+ * @group Utilities
+ */
+export function rangeOverlaps(
+  rangeLeft: { from: Date; to: Date },
+  rangeRight: { from: Date; to: Date },
+  dateLib = defaultDateLib
+): boolean {
+  return (
+    rangeIncludesDate(rangeLeft, rangeRight.from, false, dateLib) ||
+    rangeIncludesDate(rangeLeft, rangeRight.to, false, dateLib) ||
+    rangeIncludesDate(rangeRight, rangeLeft.from, false, dateLib) ||
+    rangeIncludesDate(rangeRight, rangeLeft.to, false, dateLib)
+  );
+}

package/src/utils/typeguards.test.ts

@@ -0,0 +1,83 @@
+import { defaultDateLib } from "../classes/DateLib.js";
+import type {
+  DateInterval,
+  DateRange,
+  DateAfter,
+  DateBefore,
+  DayOfWeek
+} from "../types/index.js";
+
+import {
+  isDateInterval,
+  isDateRange,
+  isDateAfterType,
+  isDateBeforeType,
+  isDayOfWeekType,
+  isDatesArray
+} from "./typeguards.js";
+
+test("isDateInterval return true for valid DateInterval", () => {
+  const validInterval: DateInterval = { before: new Date(), after: new Date() };
+  expect(isDateInterval(validInterval)).toBe(true);
+});
+
+test("isDateInterval return false for invalid DateInterval", () => {
+  expect(isDateInterval({})).toBe(false);
+  expect(isDateInterval(null)).toBe(false);
+  expect(isDateInterval(undefined)).toBe(false);
+});
+
+test("isDateRange return true for valid DateRange", () => {
+  const validRange: DateRange = { from: new Date() };
+  expect(isDateRange(validRange)).toBe(true);
+});
+
+test("isDateRange return false for invalid DateRange", () => {
+  expect(isDateRange({})).toBe(false);
+  expect(isDateRange(null)).toBe(false);
+  expect(isDateRange(undefined)).toBe(false);
+});
+
+test("isDateAfterType return true for valid DateAfter", () => {
+  const validAfter: DateAfter = { after: new Date() };
+  expect(isDateAfterType(validAfter)).toBe(true);
+});
+
+test("isDateAfterType return false for invalid DateAfter", () => {
+  expect(isDateAfterType({})).toBe(false);
+  expect(isDateAfterType(null)).toBe(false);
+  expect(isDateAfterType(undefined)).toBe(false);
+});
+
+test("isDateBeforeType return true for valid DateBefore", () => {
+  const validBefore: DateBefore = { before: new Date() };
+  expect(isDateBeforeType(validBefore)).toBe(true);
+});
+
+test("isDateBeforeType return false for invalid DateBefore", () => {
+  expect(isDateBeforeType({})).toBe(false);
+  expect(isDateBeforeType(null)).toBe(false);
+  expect(isDateBeforeType(undefined)).toBe(false);
+});
+
+test("isDayOfWeekType return true for valid DayOfWeek", () => {
+  const validDayOfWeek: DayOfWeek = { dayOfWeek: [1] };
+  expect(isDayOfWeekType(validDayOfWeek)).toBe(true);
+});
+
+test("isDayOfWeekType return false for invalid DayOfWeek", () => {
+  expect(isDayOfWeekType({})).toBe(false);
+  expect(isDayOfWeekType(null)).toBe(false);
+  expect(isDayOfWeekType(undefined)).toBe(false);
+});
+
+test("isDatesArray return true for valid array of dates", () => {
+  const validDatesArray: Date[] = [new Date(), new Date()];
+  expect(isDatesArray(validDatesArray, defaultDateLib)).toBe(true);
+});
+
+test("isDatesArray return false for invalid array of dates", () => {
+  expect(isDatesArray([{}, {}], defaultDateLib)).toBe(false);
+  expect(isDatesArray(null, defaultDateLib)).toBe(false);
+  expect(isDatesArray(undefined, defaultDateLib)).toBe(false);
+});

package/src/utils/typeguards.ts

@@ -0,0 +1,70 @@
+import type { DateLib } from "../classes/DateLib.js";
+import type {
+  DateAfter,
+  DateBefore,
+  DateInterval,
+  DateRange,
+  DayOfWeek
+} from "../types/index.js";
+
+/**
+ * Returns true if `matcher` is of type {@link DateInterval}.
+ *
+ * @group Utilities
+ */
+export function isDateInterval(matcher: unknown): matcher is DateInterval {
+  return Boolean(
+    matcher &&
+      typeof matcher === "object" &&
+      "before" in matcher &&
+      "after" in matcher
+  );
+}
+
+/**
+ * Returns true if `value` is a {@link DateRange} type.
+ *
+ * @group Utilities
+ */
+export function isDateRange(value: unknown): value is DateRange {
+  return Boolean(value && typeof value === "object" && "from" in value);
+}
+
+/**
+ * Returns true if `value` is of type {@link DateAfter}.
+ *
+ * @group Utilities
+ */
+export function isDateAfterType(value: unknown): value is DateAfter {
+  return Boolean(value && typeof value === "object" && "after" in value);
+}
+
+/**
+ * Returns true if `value` is of type {@link DateBefore}.
+ *
+ * @group Utilities
+ */
+export function isDateBeforeType(value: unknown): value is DateBefore {
+  return Boolean(value && typeof value === "object" && "before" in value);
+}
+
+/**
+ * Returns true if `value` is a {@link DayOfWeek} type.
+ *
+ * @group Utilities
+ */
+export function isDayOfWeekType(value: unknown): value is DayOfWeek {
+  return Boolean(value && typeof value === "object" && "dayOfWeek" in value);
+}
+
+/**
+ * Returns true if `value` is an array of valid dates.
+ *
+ * @private
+ */
+export function isDatesArray(
+  value: unknown,
+  dateLib: DateLib
+): value is Date[] {
+  return Array.isArray(value) && value.every(dateLib.isDate);
+}