@sprawlify/primitives 0.0.1

package/dist/date-utils-wEa1hhpc.mjs

@@ -0,0 +1,474 @@
+import { CalendarDate, DateFormatter, endOfMonth, endOfWeek, endOfYear, getLocalTimeZone, getWeeksInMonth, isSameDay, maxDate, minDate, now, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, today } from "@internationalized/date";
+
+//#region src/shared/date-utils/constrain.ts
+function alignCenter(date, duration, locale, min, max) {
+	const halfDuration = {};
+	for (let prop in duration) {
+		const key = prop;
+		const value = duration[key];
+		if (value == null) continue;
+		halfDuration[key] = Math.floor(value / 2);
+		if (halfDuration[key] > 0 && value % 2 === 0) halfDuration[key]--;
+	}
+	return constrainStart(date, alignStart(date, duration, locale).subtract(halfDuration), duration, locale, min, max);
+}
+function alignStart(date, duration, locale, min, max) {
+	let aligned = date;
+	if (duration.years) aligned = startOfYear(date);
+	else if (duration.months) aligned = startOfMonth(date);
+	else if (duration.weeks) aligned = startOfWeek(date, locale);
+	return constrainStart(date, aligned, duration, locale, min, max);
+}
+function alignEnd(date, duration, locale, min, max) {
+	let d = { ...duration };
+	if (d.days) d.days--;
+	else if (d.weeks) d.weeks--;
+	else if (d.months) d.months--;
+	else if (d.years) d.years--;
+	return constrainStart(date, alignStart(date, duration, locale).subtract(d), duration, locale, min, max);
+}
+function constrainStart(date, aligned, duration, locale, min, max) {
+	if (min && date.compare(min) >= 0) aligned = maxDate(aligned, alignStart(toCalendarDate(min), duration, locale));
+	if (max && date.compare(max) <= 0) aligned = minDate(aligned, alignEnd(toCalendarDate(max), duration, locale));
+	return aligned;
+}
+function constrainValue(date, minValue, maxValue) {
+	let constrainedDate = toCalendarDate(date);
+	if (minValue) constrainedDate = maxDate(constrainedDate, toCalendarDate(minValue));
+	if (maxValue) constrainedDate = minDate(constrainedDate, toCalendarDate(maxValue));
+	return constrainedDate;
+}
+
+//#endregion
+//#region src/shared/date-utils/align.ts
+function alignDate(date, alignment, duration, locale, min, max) {
+	switch (alignment) {
+		case "start": return alignStart(date, duration, locale, min, max);
+		case "end": return alignEnd(date, duration, locale, min, max);
+		case "center":
+		default: return alignCenter(date, duration, locale, min, max);
+	}
+}
+function alignStartDate(date, startDate, endDate, duration, locale, min, max) {
+	if (date.compare(startDate) < 0) return alignEnd(date, duration, locale, min, max);
+	if (date.compare(endDate) > 0) return alignStart(date, duration, locale, min, max);
+	return startDate;
+}
+
+//#endregion
+//#region src/shared/date-utils/assertion.ts
+function isDateEqual(dateA, dateB) {
+	if (dateA == null || dateB == null) return dateA === dateB;
+	return isSameDay(dateA, dateB);
+}
+function isDateUnavailable(date, isUnavailable, locale, minValue, maxValue) {
+	if (!date) return false;
+	if (isUnavailable?.(date, locale)) return true;
+	return isDateOutsideRange(date, minValue, maxValue);
+}
+function isDateOutsideRange(date, startDate, endDate) {
+	return startDate != null && date.compare(startDate) < 0 || endDate != null && date.compare(endDate) > 0;
+}
+function isPreviousRangeInvalid(startDate, minValue, maxValue) {
+	const prevDate = startDate.subtract({ days: 1 });
+	return isSameDay(prevDate, startDate) || isDateOutsideRange(prevDate, minValue, maxValue);
+}
+function isNextRangeInvalid(endDate, minValue, maxValue) {
+	const nextDate = endDate.add({ days: 1 });
+	return isSameDay(nextDate, endDate) || isDateOutsideRange(nextDate, minValue, maxValue);
+}
+
+//#endregion
+//#region src/shared/date-utils/duration.ts
+function getUnitDuration(duration) {
+	let clone = { ...duration };
+	for (let key in clone) clone[key] = 1;
+	return clone;
+}
+function getEndDate(startDate, duration) {
+	let clone = { ...duration };
+	if (clone.days) clone.days--;
+	else clone.days = -1;
+	return startDate.add(clone);
+}
+
+//#endregion
+//#region src/shared/date-utils/get-era-format.ts
+function getEraFormat(date) {
+	return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : void 0;
+}
+
+//#endregion
+//#region src/shared/date-utils/formatter.ts
+function getDayFormatter(locale, timeZone) {
+	return new DateFormatter(locale, {
+		weekday: "long",
+		month: "long",
+		year: "numeric",
+		day: "numeric",
+		era: getEraFormat(toCalendarDateTime(today(timeZone))),
+		timeZone
+	});
+}
+function getMonthFormatter(locale, timeZone) {
+	const date = today(timeZone);
+	return new DateFormatter(locale, {
+		month: "long",
+		year: "numeric",
+		era: getEraFormat(date),
+		calendar: date?.calendar.identifier,
+		timeZone
+	});
+}
+
+//#endregion
+//#region src/shared/date-utils/format.ts
+function formatRange(startDate, endDate, formatter, toString, timeZone) {
+	let parts = formatter.formatRangeToParts(startDate.toDate(timeZone), endDate.toDate(timeZone));
+	let separatorIndex = -1;
+	for (let i = 0; i < parts.length; i++) {
+		let part = parts[i];
+		if (part.source === "shared" && part.type === "literal") separatorIndex = i;
+		else if (part.source === "endRange") break;
+	}
+	let start = "";
+	let end = "";
+	for (let i = 0; i < parts.length; i++) if (i < separatorIndex) start += parts[i].value;
+	else if (i > separatorIndex) end += parts[i].value;
+	return toString(start, end);
+}
+function formatSelectedDate(startDate, endDate, locale, timeZone) {
+	if (!startDate) return "";
+	let start = startDate;
+	let end = endDate ?? startDate;
+	let formatter = getDayFormatter(locale, timeZone);
+	if (isSameDay(start, end)) return formatter.format(start.toDate(timeZone));
+	return formatRange(start, end, formatter, (start$1, end$1) => `${start$1} – ${end$1}`, timeZone);
+}
+function formatVisibleRange(startDate, endDate, locale, timeZone) {
+	const start = startDate;
+	const end = endDate ?? startDate;
+	const dayFormatter = getDayFormatter(locale, timeZone);
+	if (!isSameDay(start, startOfMonth(start))) return dayFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+	const monthFormatter = getMonthFormatter(locale, timeZone);
+	if (isSameDay(end, endOfMonth(start))) return monthFormatter.format(start.toDate(timeZone));
+	if (isSameDay(end, endOfMonth(end))) return monthFormatter.formatRange(start.toDate(timeZone), end.toDate(timeZone));
+	return "";
+}
+
+//#endregion
+//#region src/shared/date-utils/date-month.ts
+const daysOfTheWeek = [
+	"sun",
+	"mon",
+	"tue",
+	"wed",
+	"thu",
+	"fri",
+	"sat"
+];
+function normalizeFirstDayOfWeek(firstDayOfWeek) {
+	return firstDayOfWeek != null ? daysOfTheWeek[firstDayOfWeek] : void 0;
+}
+function getStartOfWeek(date, locale, firstDayOfWeek) {
+	return startOfWeek(date, locale, normalizeFirstDayOfWeek(firstDayOfWeek));
+}
+function getEndOfWeek(date, locale, firstDayOfWeek = 0) {
+	return endOfWeek(date, locale, normalizeFirstDayOfWeek(firstDayOfWeek));
+}
+function getDaysInWeek(weekIndex, from, locale, firstDayOfWeek) {
+	const weekDate = from.add({ weeks: weekIndex });
+	const dates = [];
+	let date = getStartOfWeek(weekDate, locale, firstDayOfWeek);
+	while (dates.length < 7) {
+		dates.push(date);
+		let nextDate = date.add({ days: 1 });
+		if (isSameDay(date, nextDate)) break;
+		date = nextDate;
+	}
+	return dates;
+}
+function getMonthDays(from, locale, numOfWeeks, firstDayOfWeek) {
+	const firstDay = normalizeFirstDayOfWeek(firstDayOfWeek);
+	const monthWeeks = numOfWeeks ?? getWeeksInMonth(from, locale, firstDay);
+	return [...new Array(monthWeeks).keys()].map((week) => getDaysInWeek(week, from, locale, firstDayOfWeek));
+}
+function getWeekdayFormats(locale, timeZone) {
+	const longFormat = new DateFormatter(locale, {
+		weekday: "long",
+		timeZone
+	});
+	const shortFormat = new DateFormatter(locale, {
+		weekday: "short",
+		timeZone
+	});
+	const narrowFormat = new DateFormatter(locale, {
+		weekday: "narrow",
+		timeZone
+	});
+	return (value) => {
+		const date = value instanceof Date ? value : value.toDate(timeZone);
+		return {
+			value,
+			short: shortFormat.format(date),
+			long: longFormat.format(date),
+			narrow: narrowFormat.format(date)
+		};
+	};
+}
+function getWeekDays(date, startOfWeekProp, timeZone, locale) {
+	const firstDayOfWeek = getStartOfWeek(date, locale, startOfWeekProp);
+	const weeks = [...new Array(7).keys()];
+	const format = getWeekdayFormats(locale, timeZone);
+	return weeks.map((index) => format(firstDayOfWeek.add({ days: index })));
+}
+function getMonthNames(locale, format = "long") {
+	const date = new Date(2021, 0, 1);
+	const monthNames = [];
+	for (let i = 0; i < 12; i++) {
+		monthNames.push(date.toLocaleString(locale, { month: format }));
+		date.setMonth(date.getMonth() + 1);
+	}
+	return monthNames;
+}
+
+//#endregion
+//#region src/shared/date-utils/date-year.ts
+function getYearsRange(range) {
+	const years = [];
+	for (let year = range.from; year <= range.to; year += 1) years.push(year);
+	return years;
+}
+const FUTURE_YEAR_COERCION = 10;
+function normalizeYear(year) {
+	if (!year) return;
+	if (year.length === 3) return year.padEnd(4, "0");
+	if (year.length === 2) {
+		const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+		const fullYear = Math.floor(currentYear / 100) * 100 + parseInt(year.slice(-2), 10);
+		return fullYear > currentYear + FUTURE_YEAR_COERCION ? (fullYear - 100).toString() : fullYear.toString();
+	}
+	return year;
+}
+function getDecadeRange(year, opts) {
+	const chunkSize = opts?.strict ? 10 : 12;
+	const computedYear = year - year % 10;
+	const years = [];
+	for (let i = 0; i < chunkSize; i += 1) {
+		const value = computedYear + i;
+		years.push(value);
+	}
+	return years;
+}
+
+//#endregion
+//#region src/shared/date-utils/mutation.ts
+function getTodayDate(timeZone) {
+	return today(timeZone ?? getLocalTimeZone());
+}
+function setCalendar(date, calendar) {
+	return toCalendar(toCalendarDateTime(date), calendar);
+}
+function setDate(date, startDate, isDateUnavailable$1, locale, minValue, maxValue) {
+	let result;
+	result = constrainValue(date, minValue, maxValue);
+	result = getPreviousAvailableDate(date, startDate, locale, isDateUnavailable$1);
+	return result;
+}
+function getPreviousAvailableDate(date, minValue, locale, isDateUnavailable$1) {
+	if (!isDateUnavailable$1) return date;
+	while (date.compare(minValue) >= 0 && isDateUnavailable$1(date, locale)) date = date.subtract({ days: 1 });
+	if (date.compare(minValue) >= 0) return date;
+}
+
+//#endregion
+//#region src/shared/date-utils/pagination.ts
+function getAdjustedDateFn(visibleDuration, locale, minValue, maxValue) {
+	return function getDate(options) {
+		const { startDate, focusedDate } = options;
+		const endDate = getEndDate(startDate, visibleDuration);
+		if (isDateOutsideRange(focusedDate, minValue, maxValue)) return {
+			startDate,
+			focusedDate: constrainValue(focusedDate, minValue, maxValue),
+			endDate
+		};
+		if (focusedDate.compare(startDate) < 0) return {
+			startDate: alignEnd(focusedDate, visibleDuration, locale, minValue, maxValue),
+			focusedDate: constrainValue(focusedDate, minValue, maxValue),
+			endDate
+		};
+		if (focusedDate.compare(endDate) > 0) return {
+			startDate: alignStart(focusedDate, visibleDuration, locale, minValue, maxValue),
+			endDate,
+			focusedDate: constrainValue(focusedDate, minValue, maxValue)
+		};
+		return {
+			startDate,
+			endDate,
+			focusedDate: constrainValue(focusedDate, minValue, maxValue)
+		};
+	};
+}
+function getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	const start = startDate.add(visibleDuration);
+	return adjust({
+		focusedDate: focusedDate.add(visibleDuration),
+		startDate: alignStart(constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue), visibleDuration, locale)
+	});
+}
+function getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	let start = startDate.subtract(visibleDuration);
+	return adjust({
+		focusedDate: focusedDate.subtract(visibleDuration),
+		startDate: alignStart(constrainStart(focusedDate, start, visibleDuration, locale, minValue, maxValue), visibleDuration, locale)
+	});
+}
+function getNextRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.days) return getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.add({ weeks: 1 }),
+		startDate
+	});
+}
+function getPreviousRow(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.days) return getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks || visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.subtract({ weeks: 1 }),
+		startDate
+	});
+}
+function getSectionStart(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.days) return adjust({
+		focusedDate: startDate,
+		startDate
+	});
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: startOfWeek(focusedDate, locale),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: startOfMonth(focusedDate),
+		startDate
+	});
+}
+function getSectionEnd(focusedDate, startDate, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	const endDate = getEndDate(startDate, visibleDuration);
+	if (visibleDuration.days) return adjust({
+		focusedDate: endDate,
+		startDate
+	});
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: endOfWeek(focusedDate, locale),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: endOfMonth(focusedDate),
+		startDate
+	});
+}
+function getNextSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (!larger && !visibleDuration.days) return adjust({
+		focusedDate: focusedDate.add(getUnitDuration(visibleDuration)),
+		startDate
+	});
+	if (visibleDuration.days) return getNextPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: focusedDate.add({ months: 1 }),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.add({ years: 1 }),
+		startDate
+	});
+}
+function getPreviousSection(focusedDate, startDate, larger, visibleDuration, locale, minValue, maxValue) {
+	const adjust = getAdjustedDateFn(visibleDuration, locale, minValue, maxValue);
+	if (!larger && !visibleDuration.days) return adjust({
+		focusedDate: focusedDate.subtract(getUnitDuration(visibleDuration)),
+		startDate
+	});
+	if (visibleDuration.days) return getPreviousPage(focusedDate, startDate, visibleDuration, locale, minValue, maxValue);
+	if (visibleDuration.weeks) return adjust({
+		focusedDate: focusedDate.subtract({ months: 1 }),
+		startDate
+	});
+	if (visibleDuration.months || visibleDuration.years) return adjust({
+		focusedDate: focusedDate.subtract({ years: 1 }),
+		startDate
+	});
+}
+
+//#endregion
+//#region src/shared/date-utils/parse-date.ts
+const isValidYear = (year) => year != null && year.length === 4;
+const isValidMonth = (month) => month != null && parseFloat(month) <= 12;
+const isValidDay = (day) => day != null && parseFloat(day) <= 31;
+function parseDateString(date, locale, timeZone) {
+	let { year, month, day } = extract(createRegex(locale, timeZone), date) ?? {};
+	if (year != null || month != null || day != null) {
+		const curr = /* @__PURE__ */ new Date();
+		year || (year = curr.getFullYear().toString());
+		month || (month = (curr.getMonth() + 1).toString());
+		day || (day = curr.getDate().toString());
+	}
+	if (!isValidYear(year)) year = normalizeYear(year);
+	if (isValidYear(year) && isValidMonth(month) && isValidDay(day)) return new CalendarDate(+year, +month, +day);
+	const time = Date.parse(date);
+	if (!isNaN(time)) {
+		const date$1 = new Date(time);
+		return new CalendarDate(date$1.getFullYear(), date$1.getMonth() + 1, date$1.getDate());
+	}
+}
+function createRegex(locale, timeZone) {
+	return new DateFormatter(locale, {
+		day: "numeric",
+		month: "numeric",
+		year: "numeric",
+		timeZone
+	}).formatToParts(new Date(2e3, 11, 25)).map(({ type, value }) => type === "literal" ? `${value}?` : `((?!=<${type}>)\\d+)?`).join("");
+}
+function extract(pattern, str) {
+	const matches = str.match(pattern);
+	return pattern.toString().match(/<(.+?)>/g)?.map((group) => {
+		const groupMatches = group.match(/<(.+)>/);
+		if (!groupMatches || groupMatches.length <= 0) return null;
+		return group.match(/<(.+)>/)?.[1];
+	}).reduce((acc, curr, index) => {
+		if (!curr) return acc;
+		if (matches && matches.length > index) acc[curr] = matches[index + 1];
+		else acc[curr] = null;
+		return acc;
+	}, {});
+}
+
+//#endregion
+//#region src/shared/date-utils/preset.ts
+function getDateRangePreset(preset, locale, timeZone) {
+	const today$1 = toCalendarDate(now(timeZone));
+	switch (preset) {
+		case "thisWeek": return [startOfWeek(today$1, locale), endOfWeek(today$1, locale)];
+		case "thisMonth": return [startOfMonth(today$1), today$1];
+		case "thisQuarter": return [startOfMonth(today$1).add({ months: -((today$1.month - 1) % 3) }), today$1];
+		case "thisYear": return [startOfYear(today$1), today$1];
+		case "last3Days": return [today$1.add({ days: -2 }), today$1];
+		case "last7Days": return [today$1.add({ days: -6 }), today$1];
+		case "last14Days": return [today$1.add({ days: -13 }), today$1];
+		case "last30Days": return [today$1.add({ days: -29 }), today$1];
+		case "last90Days": return [today$1.add({ days: -89 }), today$1];
+		case "lastMonth": return [startOfMonth(today$1.add({ months: -1 })), endOfMonth(today$1.add({ months: -1 }))];
+		case "lastQuarter": return [startOfMonth(today$1.add({ months: -((today$1.month - 1) % 3) - 3 })), endOfMonth(today$1.add({ months: -((today$1.month - 1) % 3) - 1 }))];
+		case "lastWeek": return [startOfWeek(today$1, locale).add({ weeks: -1 }), endOfWeek(today$1, locale).add({ weeks: -1 })];
+		case "lastYear": return [startOfYear(today$1.add({ years: -1 })), endOfYear(today$1.add({ years: -1 }))];
+		default: throw new Error(`Invalid date range preset: ${preset}`);
+	}
+}
+
+//#endregion
+export { getMonthFormatter as A, alignCenter as B, getStartOfWeek as C, formatSelectedDate as D, formatRange as E, isDateUnavailable as F, alignStart as H, isNextRangeInvalid as I, isPreviousRangeInvalid as L, getUnitDuration as M, isDateEqual as N, formatVisibleRange as O, isDateOutsideRange as P, alignDate as R, getMonthNames as S, getWeekdayFormats as T, constrainStart as U, alignEnd as V, constrainValue as W, getYearsRange as _, getNextRow as a, getEndOfWeek as b, getPreviousRow as c, getSectionStart as d, getPreviousAvailableDate as f, getDecadeRange as g, setDate as h, getNextPage as i, getEndDate as j, getDayFormatter as k, getPreviousSection as l, setCalendar as m, parseDateString as n, getNextSection as o, getTodayDate as p, getAdjustedDateFn as r, getPreviousPage as s, getDateRangePreset as t, getSectionEnd as u, normalizeYear as v, getWeekDays as w, getMonthDays as x, getDaysInWeek as y, alignStartDate as z };

package/dist/date-utils.cjs

@@ -0,0 +1,46 @@
+const require_date_utils = require('./date-utils-D2xPHa_I.cjs');
+
+exports.alignCenter = require_date_utils.alignCenter;
+exports.alignDate = require_date_utils.alignDate;
+exports.alignEnd = require_date_utils.alignEnd;
+exports.alignStart = require_date_utils.alignStart;
+exports.alignStartDate = require_date_utils.alignStartDate;
+exports.constrainStart = require_date_utils.constrainStart;
+exports.constrainValue = require_date_utils.constrainValue;
+exports.formatRange = require_date_utils.formatRange;
+exports.formatSelectedDate = require_date_utils.formatSelectedDate;
+exports.formatVisibleRange = require_date_utils.formatVisibleRange;
+exports.getAdjustedDateFn = require_date_utils.getAdjustedDateFn;
+exports.getDateRangePreset = require_date_utils.getDateRangePreset;
+exports.getDayFormatter = require_date_utils.getDayFormatter;
+exports.getDaysInWeek = require_date_utils.getDaysInWeek;
+exports.getDecadeRange = require_date_utils.getDecadeRange;
+exports.getEndDate = require_date_utils.getEndDate;
+exports.getEndOfWeek = require_date_utils.getEndOfWeek;
+exports.getMonthDays = require_date_utils.getMonthDays;
+exports.getMonthFormatter = require_date_utils.getMonthFormatter;
+exports.getMonthNames = require_date_utils.getMonthNames;
+exports.getNextPage = require_date_utils.getNextPage;
+exports.getNextRow = require_date_utils.getNextRow;
+exports.getNextSection = require_date_utils.getNextSection;
+exports.getPreviousAvailableDate = require_date_utils.getPreviousAvailableDate;
+exports.getPreviousPage = require_date_utils.getPreviousPage;
+exports.getPreviousRow = require_date_utils.getPreviousRow;
+exports.getPreviousSection = require_date_utils.getPreviousSection;
+exports.getSectionEnd = require_date_utils.getSectionEnd;
+exports.getSectionStart = require_date_utils.getSectionStart;
+exports.getStartOfWeek = require_date_utils.getStartOfWeek;
+exports.getTodayDate = require_date_utils.getTodayDate;
+exports.getUnitDuration = require_date_utils.getUnitDuration;
+exports.getWeekDays = require_date_utils.getWeekDays;
+exports.getWeekdayFormats = require_date_utils.getWeekdayFormats;
+exports.getYearsRange = require_date_utils.getYearsRange;
+exports.isDateEqual = require_date_utils.isDateEqual;
+exports.isDateOutsideRange = require_date_utils.isDateOutsideRange;
+exports.isDateUnavailable = require_date_utils.isDateUnavailable;
+exports.isNextRangeInvalid = require_date_utils.isNextRangeInvalid;
+exports.isPreviousRangeInvalid = require_date_utils.isPreviousRangeInvalid;
+exports.normalizeYear = require_date_utils.normalizeYear;
+exports.parseDateString = require_date_utils.parseDateString;
+exports.setCalendar = require_date_utils.setCalendar;
+exports.setDate = require_date_utils.setDate;

package/dist/date-utils.d.cts

@@ -0,0 +1,101 @@
+import { a as DateRangePreset, i as DateGranularity, n as DateAlignment, r as DateAvailableFn, t as DateAdjustFn } from "./types-GxLIgJib.cjs";
+import * as _internationalized_date0 from "@internationalized/date";
+import { Calendar, DateDuration, DateFormatter, DateValue } from "@internationalized/date";
+
+//#region src/shared/date-utils/align.d.ts
+declare function alignDate(date: DateValue, alignment: DateAlignment, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): DateValue;
+declare function alignStartDate(date: DateValue, startDate: DateValue, endDate: DateValue, duration: DateDuration, locale: string, min?: DateValue | undefined, max?: DateValue | undefined): DateValue;
+//#endregion
+//#region src/shared/date-utils/assertion.d.ts
+declare function isDateEqual(dateA: DateValue | null | undefined, dateB?: DateValue | null): boolean;
+declare function isDateUnavailable(date: DateValue | null, isUnavailable: DateAvailableFn | undefined, locale: string, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isDateOutsideRange(date: DateValue, startDate?: DateValue | null, endDate?: DateValue | null): boolean;
+declare function isPreviousRangeInvalid(startDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+declare function isNextRangeInvalid(endDate: DateValue, minValue?: DateValue | null, maxValue?: DateValue | null): boolean;
+//#endregion
+//#region src/shared/date-utils/constrain.d.ts
+declare function alignCenter(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignStart(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function alignEnd(date: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainStart(date: DateValue, aligned: DateValue, duration: DateDuration, locale: string, min?: DateValue, max?: DateValue): DateValue;
+declare function constrainValue(date: DateValue, minValue?: DateValue, maxValue?: DateValue): DateValue;
+//#endregion
+//#region src/shared/date-utils/duration.d.ts
+declare function getUnitDuration(duration: DateDuration): {
+  years?: number;
+  months?: number;
+  weeks?: number;
+  days?: number;
+};
+declare function getEndDate(startDate: DateValue, duration: DateDuration): _internationalized_date0.CalendarDate | _internationalized_date0.CalendarDateTime | _internationalized_date0.ZonedDateTime;
+//#endregion
+//#region src/shared/date-utils/format.d.ts
+declare function formatRange(startDate: DateValue, endDate: DateValue, formatter: DateFormatter, toString: (start: string, end: string) => string, timeZone: string): string;
+declare function formatSelectedDate(startDate: DateValue | null | undefined, endDate: DateValue | null, locale: string, timeZone: string): string;
+declare function formatVisibleRange(startDate: DateValue, endDate: DateValue | null, locale: string, timeZone: string): string;
+//#endregion
+//#region src/shared/date-utils/formatter.d.ts
+declare function getDayFormatter(locale: string, timeZone: string): DateFormatter;
+declare function getMonthFormatter(locale: string, timeZone: string): DateFormatter;
+//#endregion
+//#region src/shared/date-utils/date-month.d.ts
+declare function getStartOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getEndOfWeek(date: DateValue, locale: string, firstDayOfWeek?: number): DateValue;
+declare function getDaysInWeek(weekIndex: number, from: DateValue, locale: string, firstDayOfWeek?: number): DateValue[];
+declare function getMonthDays(from: DateValue, locale: string, numOfWeeks?: number, firstDayOfWeek?: number): DateValue[][];
+declare function getWeekdayFormats(locale: string, timeZone: string): <T extends DateValue | Date>(value: T) => {
+  value: T;
+  short: string;
+  long: string;
+  narrow: string;
+};
+declare function getWeekDays(date: DateValue, startOfWeekProp: number | undefined, timeZone: string, locale: string): {
+  value: _internationalized_date0.CalendarDate | _internationalized_date0.CalendarDateTime | _internationalized_date0.ZonedDateTime;
+  short: string;
+  long: string;
+  narrow: string;
+}[];
+declare function getMonthNames(locale: string, format?: Intl.DateTimeFormatOptions["month"]): string[];
+//#endregion
+//#region src/shared/date-utils/date-year.d.ts
+interface YearsRange {
+  from: number;
+  to: number;
+}
+declare function getYearsRange(range: YearsRange): number[];
+declare function normalizeYear(year: string | null | undefined): string | undefined;
+declare function getDecadeRange(year: number, opts?: {
+  strict?: boolean;
+}): number[];
+//#endregion
+//#region src/shared/date-utils/mutation.d.ts
+declare function getTodayDate(timeZone?: string): _internationalized_date0.CalendarDate;
+declare function setCalendar(date: DateValue, calendar: Calendar): _internationalized_date0.CalendarDateTime;
+declare function setDate(date: DateValue, startDate: DateValue, isDateUnavailable: DateAvailableFn, locale: string, minValue: DateValue, maxValue: DateValue): DateValue | undefined;
+declare function getPreviousAvailableDate(date: DateValue, minValue: DateValue, locale: string, isDateUnavailable?: DateAvailableFn): DateValue | undefined;
+//#endregion
+//#region src/shared/date-utils/pagination.d.ts
+interface AdjustDateParams {
+  startDate: DateValue;
+  focusedDate: DateValue;
+}
+interface AdjustDateReturn extends AdjustDateParams {
+  endDate: DateValue;
+}
+declare function getAdjustedDateFn(visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): (options: AdjustDateParams) => AdjustDateReturn;
+declare function getNextPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getPreviousPage(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn;
+declare function getNextRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousRow(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionStart(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getSectionEnd(focusedDate: DateValue, startDate: DateValue, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getNextSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+declare function getPreviousSection(focusedDate: DateValue, startDate: DateValue, larger: boolean, visibleDuration: DateDuration, locale: string, minValue?: DateValue, maxValue?: DateValue): AdjustDateReturn | undefined;
+//#endregion
+//#region src/shared/date-utils/parse-date.d.ts
+declare function parseDateString(date: string, locale: string, timeZone: string): DateValue | undefined;
+//#endregion
+//#region src/shared/date-utils/preset.d.ts
+declare function getDateRangePreset(preset: DateRangePreset, locale: string, timeZone: string): [DateValue, DateValue];
+//#endregion
+export { AdjustDateParams, AdjustDateReturn, DateAdjustFn, DateGranularity, DateRangePreset, YearsRange, alignCenter, alignDate, alignEnd, alignStart, alignStartDate, constrainStart, constrainValue, formatRange, formatSelectedDate, formatVisibleRange, getAdjustedDateFn, getDateRangePreset, getDayFormatter, getDaysInWeek, getDecadeRange, getEndDate, getEndOfWeek, getMonthDays, getMonthFormatter, getMonthNames, getNextPage, getNextRow, getNextSection, getPreviousAvailableDate, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart, getStartOfWeek, getTodayDate, getUnitDuration, getWeekDays, getWeekdayFormats, getYearsRange, isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid, normalizeYear, parseDateString, setCalendar, setDate };

package/dist/date-utils.d.mts

@@ -0,0 +1,2 @@
+import { A as getMonthFormatter, B as constrainValue, C as getEndOfWeek, D as getWeekDays, E as getStartOfWeek, F as getUnitDuration, G as isPreviousRangeInvalid, H as isDateOutsideRange, I as alignCenter, J as DateAdjustFn, K as alignDate, L as alignEnd, M as formatSelectedDate, N as formatVisibleRange, O as getWeekdayFormats, P as getEndDate, R as alignStart, S as getDaysInWeek, T as getMonthNames, U as isDateUnavailable, V as isDateEqual, W as isNextRangeInvalid, X as DateRangePreset, Y as DateGranularity, _ as setDate, a as getAdjustedDateFn, b as getYearsRange, c as getNextSection, d as getPreviousSection, f as getSectionEnd, g as setCalendar, h as getTodayDate, i as AdjustDateReturn, j as formatRange, k as getDayFormatter, l as getPreviousPage, m as getPreviousAvailableDate, n as parseDateString, o as getNextPage, p as getSectionStart, q as alignStartDate, r as AdjustDateParams, s as getNextRow, t as getDateRangePreset, u as getPreviousRow, v as YearsRange, w as getMonthDays, x as normalizeYear, y as getDecadeRange, z as constrainStart } from "./index-CD5FN7kY.mjs";
+export { AdjustDateParams, AdjustDateReturn, DateAdjustFn, DateGranularity, DateRangePreset, YearsRange, alignCenter, alignDate, alignEnd, alignStart, alignStartDate, constrainStart, constrainValue, formatRange, formatSelectedDate, formatVisibleRange, getAdjustedDateFn, getDateRangePreset, getDayFormatter, getDaysInWeek, getDecadeRange, getEndDate, getEndOfWeek, getMonthDays, getMonthFormatter, getMonthNames, getNextPage, getNextRow, getNextSection, getPreviousAvailableDate, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart, getStartOfWeek, getTodayDate, getUnitDuration, getWeekDays, getWeekdayFormats, getYearsRange, isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid, normalizeYear, parseDateString, setCalendar, setDate };

package/dist/date-utils.mjs

@@ -0,0 +1,3 @@
+import { A as getMonthFormatter, B as alignCenter, C as getStartOfWeek, D as formatSelectedDate, E as formatRange, F as isDateUnavailable, H as alignStart, I as isNextRangeInvalid, L as isPreviousRangeInvalid, M as getUnitDuration, N as isDateEqual, O as formatVisibleRange, P as isDateOutsideRange, R as alignDate, S as getMonthNames, T as getWeekdayFormats, U as constrainStart, V as alignEnd, W as constrainValue, _ as getYearsRange, a as getNextRow, b as getEndOfWeek, c as getPreviousRow, d as getSectionStart, f as getPreviousAvailableDate, g as getDecadeRange, h as setDate, i as getNextPage, j as getEndDate, k as getDayFormatter, l as getPreviousSection, m as setCalendar, n as parseDateString, o as getNextSection, p as getTodayDate, r as getAdjustedDateFn, s as getPreviousPage, t as getDateRangePreset, u as getSectionEnd, v as normalizeYear, w as getWeekDays, x as getMonthDays, y as getDaysInWeek, z as alignStartDate } from "./date-utils-wEa1hhpc.mjs";
+
+export { alignCenter, alignDate, alignEnd, alignStart, alignStartDate, constrainStart, constrainValue, formatRange, formatSelectedDate, formatVisibleRange, getAdjustedDateFn, getDateRangePreset, getDayFormatter, getDaysInWeek, getDecadeRange, getEndDate, getEndOfWeek, getMonthDays, getMonthFormatter, getMonthNames, getNextPage, getNextRow, getNextSection, getPreviousAvailableDate, getPreviousPage, getPreviousRow, getPreviousSection, getSectionEnd, getSectionStart, getStartOfWeek, getTodayDate, getUnitDuration, getWeekDays, getWeekdayFormats, getYearsRange, isDateEqual, isDateOutsideRange, isDateUnavailable, isNextRangeInvalid, isPreviousRangeInvalid, normalizeYear, parseDateString, setCalendar, setDate };