@octanejs/day-picker 0.0.1

package/src/utils/dateMatchModifiers.ts

@@ -0,0 +1,72 @@
+import { type DateLib, defaultDateLib } from '../classes/DateLib.js';
+import type { Matcher } from '../types/index.js';
+
+import { rangeIncludesDate } from './rangeIncludesDate.js';
+import {
+	isDateAfterType,
+	isDateBeforeType,
+	isDateInterval,
+	isDateRange,
+	isDatesArray,
+	isDayOfWeekType,
+} from './typeguards.js';
+
+/**
+ * Checks if a given date matches at least one of the specified {@link Matcher}.
+ *
+ * @param date - The date to check.
+ * @param matchers - The matchers to check against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the date matches any of the matchers, otherwise `false`.
+ * @group Utilities
+ */
+export function dateMatchModifiers(
+	date: Date,
+	matchers: Matcher | Matcher[],
+	dateLib: DateLib = defaultDateLib,
+): boolean {
+	const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
+	const { isSameDay, differenceInCalendarDays, isAfter } = dateLib;
+	return matchersArr.some((matcher: Matcher) => {
+		if (typeof matcher === 'boolean') {
+			return matcher;
+		}
+		if (dateLib.isDate(matcher)) {
+			return isSameDay(date, matcher);
+		}
+		if (isDatesArray(matcher, dateLib)) {
+			return matcher.some((matcherDate) => isSameDay(date, matcherDate));
+		}
+		if (isDateRange(matcher)) {
+			return rangeIncludesDate(matcher, date, false, dateLib);
+		}
+		if (isDayOfWeekType(matcher)) {
+			if (!Array.isArray(matcher.dayOfWeek)) {
+				return matcher.dayOfWeek === date.getDay();
+			}
+			return matcher.dayOfWeek.includes(date.getDay());
+		}
+		if (isDateInterval(matcher)) {
+			const diffBefore = differenceInCalendarDays(matcher.before, date);
+			const diffAfter = differenceInCalendarDays(matcher.after, date);
+			const isDayBefore = diffBefore > 0;
+			const isDayAfter = diffAfter < 0;
+			const isClosedInterval = isAfter(matcher.before, matcher.after);
+			if (isClosedInterval) {
+				return isDayAfter && isDayBefore;
+			} else {
+				return isDayBefore || isDayAfter;
+			}
+		}
+		if (isDateAfterType(matcher)) {
+			return differenceInCalendarDays(date, matcher.after) > 0;
+		}
+		if (isDateBeforeType(matcher)) {
+			return differenceInCalendarDays(matcher.before, date) > 0;
+		}
+		if (typeof matcher === 'function') {
+			return matcher(date);
+		}
+		return false;
+	});
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './addToRange.js';
+export * from './dateMatchModifiers.js';
+export * from './rangeContainsDayOfWeek.js';
+export * from './rangeContainsModifiers.js';
+export * from './rangeIncludesDate.js';
+export * from './rangeOverlaps.js';
+export * from './typeguards.js';

package/src/utils/rangeContainsDayOfWeek.ts

@@ -0,0 +1,33 @@
+import { type DateLib, defaultDateLib } from '../classes/DateLib.js';
+
+/**
+ * Checks if a date range contains one or more specified days of the week.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param dayOfWeek - The day(s) of the week to check for (`0-6`, where `0` is
+ *   Sunday).
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains the specified day(s) of the week,
+ *   otherwise `false`.
+ * @group Utilities
+ */
+export function rangeContainsDayOfWeek(
+	range: { from: Date; to: Date },
+	dayOfWeek: number | number[],
+	dateLib: DateLib = defaultDateLib,
+) {
+	const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
+	let date = range.from;
+	const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+
+	// iterate at maximum one week or the total days if the range is shorter than one week
+	const totalDaysLimit = Math.min(totalDays, 6);
+	for (let i = 0; i <= totalDaysLimit; i++) {
+		if (dayOfWeekArr.includes(date.getDay())) {
+			return true;
+		}
+		date = dateLib.addDays(date, 1);
+	}
+	return false;
+}

package/src/utils/rangeContainsModifiers.ts

@@ -0,0 +1,106 @@
+import { type DateLib, defaultDateLib } from '../classes/DateLib.js';
+import type { Matcher } from '../types/index.js';
+
+import { dateMatchModifiers } from './dateMatchModifiers.js';
+import { rangeContainsDayOfWeek } from './rangeContainsDayOfWeek.js';
+import { rangeIncludesDate } from './rangeIncludesDate.js';
+import { rangeOverlaps } from './rangeOverlaps.js';
+import {
+	isDateAfterType,
+	isDateBeforeType,
+	isDateInterval,
+	isDateRange,
+	isDatesArray,
+	isDayOfWeekType,
+} from './typeguards.js';
+
+/**
+ * Checks if a date range contains dates that match the given modifiers.
+ *
+ * @since 9.2.2
+ * @param range - The date range to check.
+ * @param modifiers - The modifiers to match against.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the range contains matching dates, otherwise `false`.
+ * @group Utilities
+ */
+export function rangeContainsModifiers(
+	range: { from: Date; to: Date },
+	modifiers: Matcher | Matcher[],
+	dateLib: DateLib = defaultDateLib,
+): boolean {
+	const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
+
+	// Defer function matchers evaluation as they are the least performant.
+	const nonFunctionMatchers = matchers.filter((matcher) => typeof matcher !== 'function');
+
+	const nonFunctionMatchersResult = nonFunctionMatchers.some((matcher) => {
+		if (typeof matcher === 'boolean') return matcher;
+
+		if (dateLib.isDate(matcher)) {
+			return rangeIncludesDate(range, matcher, false, dateLib);
+		}
+
+		if (isDatesArray(matcher, dateLib)) {
+			return matcher.some((date) => rangeIncludesDate(range, date, false, dateLib));
+		}
+
+		if (isDateRange(matcher)) {
+			if (matcher.from && matcher.to) {
+				return rangeOverlaps(range, { from: matcher.from, to: matcher.to }, dateLib);
+			}
+			return false;
+		}
+
+		if (isDayOfWeekType(matcher)) {
+			return rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
+		}
+
+		if (isDateInterval(matcher)) {
+			const isClosedInterval = dateLib.isAfter(matcher.before, matcher.after);
+			if (isClosedInterval) {
+				return rangeOverlaps(
+					range,
+					{
+						from: dateLib.addDays(matcher.after, 1),
+						to: dateLib.addDays(matcher.before, -1),
+					},
+					dateLib,
+				);
+			}
+			return (
+				dateMatchModifiers(range.from, matcher, dateLib) ||
+				dateMatchModifiers(range.to, matcher, dateLib)
+			);
+		}
+
+		if (isDateAfterType(matcher) || isDateBeforeType(matcher)) {
+			return (
+				dateMatchModifiers(range.from, matcher, dateLib) ||
+				dateMatchModifiers(range.to, matcher, dateLib)
+			);
+		}
+
+		return false;
+	});
+
+	if (nonFunctionMatchersResult) {
+		return true;
+	}
+
+	const functionMatchers = matchers.filter((matcher) => typeof matcher === 'function');
+
+	if (functionMatchers.length) {
+		let date = range.from;
+		const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
+
+		for (let i = 0; i <= totalDays; i++) {
+			if (functionMatchers.some((matcher) => matcher(date))) {
+				return true;
+			}
+			date = dateLib.addDays(date, 1);
+		}
+	}
+
+	return false;
+}

package/src/utils/rangeIncludesDate.ts

@@ -0,0 +1,40 @@
+import { defaultDateLib } from '../classes/index.js';
+import type { DateRange } from '../types/index.js';
+
+/**
+ * Checks if a given date is within a specified date range.
+ *
+ * @since 9.0.0
+ * @param range - The date range to check against.
+ * @param date - The date to check.
+ * @param excludeEnds - If `true`, the range's start and end dates are excluded.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the date is within the range, otherwise `false`.
+ * @group Utilities
+ */
+export function rangeIncludesDate(
+	range: DateRange,
+	date: Date,
+	excludeEnds = false,
+	dateLib = defaultDateLib,
+): boolean {
+	let { from, to } = range;
+	const { differenceInCalendarDays, isSameDay } = dateLib;
+	if (from && to) {
+		const isRangeInverted = differenceInCalendarDays(to, from) < 0;
+		if (isRangeInverted) {
+			[from, to] = [to, from];
+		}
+		const isInRange =
+			differenceInCalendarDays(date, from) >= (excludeEnds ? 1 : 0) &&
+			differenceInCalendarDays(to, date) >= (excludeEnds ? 1 : 0);
+		return isInRange;
+	}
+	if (!excludeEnds && to) {
+		return isSameDay(to, date);
+	}
+	if (!excludeEnds && from) {
+		return isSameDay(from, date);
+	}
+	return false;
+}

package/src/utils/rangeOverlaps.ts

@@ -0,0 +1,26 @@
+import { defaultDateLib } from '../classes/index.js';
+
+import { rangeIncludesDate } from './rangeIncludesDate.js';
+
+/**
+ * Determines if two date ranges overlap.
+ *
+ * @since 9.2.2
+ * @param rangeLeft - The first date range.
+ * @param rangeRight - The second date range.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the ranges overlap, otherwise `false`.
+ * @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/toTimeZone.ts

@@ -0,0 +1,13 @@
+import { TZDate } from '@date-fns/tz';
+
+/**
+ * Convert a {@link Date} or {@link TZDate} instance to the given time zone.
+ * Reuses the same instance when it is already a {@link TZDate} using the target
+ * time zone to avoid extra allocations.
+ */
+export function toTimeZone(date: Date, timeZone: string): TZDate {
+	if (date instanceof TZDate && date.timeZone === timeZone) {
+		return date;
+	}
+	return new TZDate(date, timeZone);
+}

package/src/utils/typeguards.ts

@@ -0,0 +1,71 @@
+import type { DateLib } from '../classes/DateLib.js';
+import type { DateAfter, DateBefore, DateInterval, DateRange, DayOfWeek } from '../types/index.js';
+
+/**
+ * Checks if the given value is of type {@link DateInterval}.
+ *
+ * @param matcher - The value to check.
+ * @returns `true` if the value is a {@link DateInterval}, otherwise `false`.
+ * @group Utilities
+ */
+export function isDateInterval(matcher: unknown): matcher is DateInterval {
+	return Boolean(
+		matcher && typeof matcher === 'object' && 'before' in matcher && 'after' in matcher,
+	);
+}
+
+/**
+ * Checks if the given value is of type {@link DateRange}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DateRange}, otherwise `false`.
+ * @group Utilities
+ */
+export function isDateRange(value: unknown): value is DateRange {
+	return Boolean(value && typeof value === 'object' && 'from' in value);
+}
+
+/**
+ * Checks if the given value is of type {@link DateAfter}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DateAfter}, otherwise `false`.
+ * @group Utilities
+ */
+export function isDateAfterType(value: unknown): value is DateAfter {
+	return Boolean(value && typeof value === 'object' && 'after' in value);
+}
+
+/**
+ * Checks if the given value is of type {@link DateBefore}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DateBefore}, otherwise `false`.
+ * @group Utilities
+ */
+export function isDateBeforeType(value: unknown): value is DateBefore {
+	return Boolean(value && typeof value === 'object' && 'before' in value);
+}
+
+/**
+ * Checks if the given value is of type {@link DayOfWeek}.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a {@link DayOfWeek}, otherwise `false`.
+ * @group Utilities
+ */
+export function isDayOfWeekType(value: unknown): value is DayOfWeek {
+	return Boolean(value && typeof value === 'object' && 'dayOfWeek' in value);
+}
+
+/**
+ * Checks if the given value is an array of valid dates.
+ *
+ * @private
+ * @param value - The value to check.
+ * @param dateLib - The date utility library instance.
+ * @returns `true` if the value is an array of valid dates, otherwise `false`.
+ */
+export function isDatesArray(value: unknown, dateLib: DateLib): value is Date[] {
+	return Array.isArray(value) && value.every(dateLib.isDate);
+}

package/status.json

@@ -0,0 +1,13 @@
+{
+  "upstream": {
+    "package": "react-day-picker",
+    "version": "10.0.1",
+    "commit": "6d3929d655779d178638d8f80171597a579468e8"
+  },
+  "surface": "DayPicker, public components, hooks, date classes, helpers, labels, formatters, locales, styles, and public types.",
+  "divergences": [
+    "React DOM prop types are preserved publicly and normalized at Octane render boundaries."
+  ],
+  "ssr": "Calendar markup and accessibility attributes render without browser globals.",
+  "verified": "2026-08-02"
+}