@warlock.js/seal 4.0.171 → 4.1.1

package/esm/validators/date-validator.mjs

@@ -0,0 +1,637 @@
+import { applyNullable, getRuleOptions } from "../standard-schema/json-schema.mjs";
+import { isDateValue } from "../helpers/date-helpers.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+import { addDaysMutator, addHoursMutator, addMonthsMutator, addYearsMutator, dateMutator, toEndOfDayMutator, toEndOfMonthMutator, toEndOfYearMutator, toStartOfDayMutator, toStartOfMonthMutator, toStartOfYearMutator, toUTCMutator } from "../mutators/date-mutators.mjs";
+import "../mutators/index.mjs";
+import { ageRule, beforeHourRule, beforeMinuteRule, beforeTodayRule, betweenHoursRule, betweenMinutesRule, dateRule, fromHourRule, fromMinuteRule, fromTodayRule, maxAgeRule, maxDateRule, minAgeRule, minDateRule, weekDayRule } from "../rules/date/date.mjs";
+import { afterTodayRule, betweenDatesRule, futureRule, pastRule, todayRule } from "../rules/date/date-comparison-rules.mjs";
+import { businessDayRule, weekdaysRule, weekendRule } from "../rules/date/date-day-rules.mjs";
+import { afterFieldRule, beforeFieldRule, sameAsFieldDateRule } from "../rules/date/date-field-comparison-rules.mjs";
+import { betweenDaysRule, betweenMonthsRule, betweenTimesRule, betweenYearsRule, maxDayRule, maxMonthRule, maxYearRule, minDayRule, minMonthRule, minYearRule, monthRule, quarterRule, yearRule } from "../rules/date/date-period-rules.mjs";
+import { withinDaysRule, withinFutureDaysRule, withinPastDaysRule } from "../rules/date/date-relative-rules.mjs";
+import { betweenAgeRule, birthdayRule, leapYearRule } from "../rules/date/date-special-rules.mjs";
+import "../rules/index.mjs";
+import dayjs from "dayjs";
+
+//#region ../../@warlock.js/seal/src/validators/date-validator.ts
+/**
+* Date validator class
+*/
+var DateValidator = class extends BaseValidator {
+	constructor(errorMessage) {
+		super();
+		this.addMutableMutator(dateMutator);
+		this.addMutableRule(dateRule, errorMessage);
+	}
+	/**
+	* Check if value is a Date type
+	*/
+	matchesType(value) {
+		return isDateValue(value);
+	}
+	/**
+	* Convert date to ISO string format
+	* @category transformer
+	*/
+	toISOString() {
+		return this.addTransformer((data) => data instanceof Date ? data.toISOString() : data);
+	}
+	/** Convert date to Unix timestamp (milliseconds) */
+	toTimestamp() {
+		return this.addTransformer((data) => data instanceof Date ? data.getTime() : data);
+	}
+	/** Convert date to specific format using dayjs */
+	toFormat(format) {
+		return this.addTransformer((data, { options }) => data instanceof Date ? dayjs(data).format(options.format) : data, { format });
+	}
+	/** Convert to date only (remove time, returns YYYY-MM-DD) */
+	toDateOnly() {
+		return this.addTransformer((data) => data instanceof Date ? dayjs(data).format("YYYY-MM-DD") : data, { __jsonSchemaFormat: "date" });
+	}
+	/** Convert to time only (returns HH:MM:SS) */
+	toTimeOnly() {
+		return this.addTransformer((data) => data instanceof Date ? dayjs(data).format("HH:mm:ss") : data, { __jsonSchemaFormat: "time" });
+	}
+	/**
+	* Convert date to start of day (00:00:00)
+	* @category mutator
+	*/
+	toStartOfDay() {
+		return this.addMutator(toStartOfDayMutator);
+	}
+	/** Convert date to end of day (23:59:59.999) */
+	toEndOfDay() {
+		return this.addMutator(toEndOfDayMutator);
+	}
+	/** Add or subtract days from date */
+	addDays(days) {
+		return this.addMutator(addDaysMutator, { days });
+	}
+	/** Add or subtract months from date */
+	addMonths(months) {
+		return this.addMutator(addMonthsMutator, { months });
+	}
+	/** Add or subtract years from date */
+	addYears(years) {
+		return this.addMutator(addYearsMutator, { years });
+	}
+	/** Add or subtract hours from date */
+	addHours(hours) {
+		return this.addMutator(addHoursMutator, { hours });
+	}
+	/** Convert date to UTC */
+	toUTC() {
+		return this.addMutator(toUTCMutator);
+	}
+	/** Set to start of month */
+	toStartOfMonth() {
+		return this.addMutator(toStartOfMonthMutator);
+	}
+	/** Set to end of month */
+	toEndOfMonth() {
+		return this.addMutator(toEndOfMonthMutator);
+	}
+	/** Set to start of year */
+	toStartOfYear() {
+		return this.addMutator(toStartOfYearMutator);
+	}
+	/** Set to end of year */
+	toEndOfYear() {
+		return this.addMutator(toEndOfYearMutator);
+	}
+	/**
+	* Date must be greater than or equal to the given date or field (inclusive)
+	*
+	* Smart detection:
+	* - Date instance, timestamp, or date string (with - or /) → value comparison
+	* - Plain string → field comparison
+	*
+	* @param dateOrField - Date, timestamp, date string, or field name
+	*
+	* @example
+	* ```ts
+	* // Value comparison
+	* v.date().min('2024-01-01')
+	* v.date().min(new Date())
+	* v.date().min(1698278400000)
+	*
+	* // Field comparison
+	* v.date().min('startsAt')
+	* ```
+	*
+	* @category Validation Rule
+	*/
+	min(dateOrField, errorMessage) {
+		return this.addRule(minDateRule, errorMessage, {
+			dateOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Date must be less than or equal to the given date or field (inclusive)
+	*
+	* Smart detection:
+	* - Date instance, timestamp, or date string (with - or /) → value comparison
+	* - Plain string → field comparison
+	*
+	* @category Validation Rule
+	*/
+	max(dateOrField, errorMessage) {
+		return this.addRule(maxDateRule, errorMessage, {
+			dateOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Date must be strictly less than the given date or field (exclusive)
+	*
+	* Smart detection:
+	* - Date instance, timestamp, or date string (with - or /) → value comparison
+	* - Plain string → field comparison
+	*
+	* @category Validation Rule
+	*/
+	before(dateOrField, errorMessage) {
+		return this.addRule(beforeFieldRule, errorMessage, {
+			dateOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Date must be strictly greater than the given date or field (exclusive)
+	*
+	* Smart detection:
+	* - Date instance, timestamp, or date string (with - or /) → value comparison
+	* - Plain string → field comparison
+	*
+	* @category Validation Rule
+	*/
+	after(dateOrField, errorMessage) {
+		return this.addRule(afterFieldRule, errorMessage, {
+			dateOrField,
+			scope: "global"
+		});
+	}
+	/** Date must be between start and end dates */
+	between(startDate, endDate, errorMessage) {
+		return this.addRule(betweenDatesRule, errorMessage, {
+			startDate,
+			endDate
+		});
+	}
+	/** Date must be exactly today */
+	today(errorMessage) {
+		return this.addRule(todayRule, errorMessage);
+	}
+	/** Date must be today or in the future */
+	fromToday(errorMessage) {
+		return this.addRule(fromTodayRule, errorMessage);
+	}
+	/** Date must be before today */
+	beforeToday(errorMessage) {
+		return this.addRule(beforeTodayRule, errorMessage);
+	}
+	/** Date must be after today (not including today) */
+	afterToday(errorMessage) {
+		return this.addRule(afterTodayRule, errorMessage);
+	}
+	/** Date must be in the past */
+	past(errorMessage) {
+		return this.addRule(pastRule, errorMessage);
+	}
+	/** Date must be in the future */
+	future(errorMessage) {
+		return this.addRule(futureRule, errorMessage);
+	}
+	/**
+	* Date must be >= sibling field value (inclusive)
+	* @category Validation Rule
+	*/
+	minSibling(field, errorMessage) {
+		return this.addRule(minDateRule, errorMessage, {
+			dateOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Date must be <= sibling field value (inclusive)
+	* @category Validation Rule
+	*/
+	maxSibling(field, errorMessage) {
+		return this.addRule(maxDateRule, errorMessage, {
+			dateOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Date must be < sibling field value (exclusive)
+	* @category Validation Rule
+	*/
+	beforeSibling(field, errorMessage) {
+		return this.addRule(beforeFieldRule, errorMessage, {
+			dateOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Date must be > sibling field value (exclusive)
+	* @category Validation Rule
+	*/
+	afterSibling(field, errorMessage) {
+		return this.addRule(afterFieldRule, errorMessage, {
+			dateOrField: field,
+			scope: "sibling"
+		});
+	}
+	/** Date must be the same as another field's date */
+	sameAsField(field, errorMessage) {
+		return this.addRule(sameAsFieldDateRule, errorMessage, {
+			field,
+			scope: "global"
+		});
+	}
+	/** Date must be the same as another sibling field's date */
+	sameAsFieldSibling(field, errorMessage) {
+		return this.addRule(sameAsFieldDateRule, errorMessage, {
+			field,
+			scope: "sibling"
+		});
+	}
+	/** Time must be from specific hour onwards (0-23) */
+	fromHour(hour, errorMessage) {
+		return this.addRule(fromHourRule, errorMessage, { hour });
+	}
+	/** Time must be before specific hour (0-23) */
+	beforeHour(hour, errorMessage) {
+		return this.addRule(beforeHourRule, errorMessage, { hour });
+	}
+	/** Time must be between start and end hours (0-23) */
+	betweenHours(startHour, endHour, errorMessage) {
+		return this.addRule(betweenHoursRule, errorMessage, {
+			startHour,
+			endHour
+		});
+	}
+	/** Time must be from specific minute onwards (0-59) */
+	fromMinute(minute, errorMessage) {
+		return this.addRule(fromMinuteRule, errorMessage, { minute });
+	}
+	/** Time must be before specific minute (0-59) */
+	beforeMinute(minute, errorMessage) {
+		return this.addRule(beforeMinuteRule, errorMessage, { minute });
+	}
+	/** Time must be between start and end minutes (0-59) */
+	betweenMinutes(startMinute, endMinute, errorMessage) {
+		return this.addRule(betweenMinutesRule, errorMessage, {
+			startMinute,
+			endMinute
+		});
+	}
+	/** Time must be between start and end times (HH:MM format) */
+	betweenTimes(startTime, endTime, errorMessage) {
+		return this.addRule(betweenTimesRule, errorMessage, {
+			startTime,
+			endTime
+		});
+	}
+	/** Age must be exactly the given years */
+	age(years, errorMessage) {
+		return this.addRule(ageRule, errorMessage, { years });
+	}
+	/** Minimum age requirement */
+	minAge(years, errorMessage) {
+		return this.addRule(minAgeRule, errorMessage, { years });
+	}
+	/** Maximum age requirement */
+	maxAge(years, errorMessage) {
+		return this.addRule(maxAgeRule, errorMessage, { years });
+	}
+	/** Age must be between min and max years */
+	betweenAge(minAge, maxAge, errorMessage) {
+		return this.addRule(betweenAgeRule, errorMessage, {
+			minAge,
+			maxAge
+		});
+	}
+	/** Date must be specific weekday */
+	weekDay(day, errorMessage) {
+		return this.addRule(weekDayRule, errorMessage, { day });
+	}
+	/** Date must be one of specified weekdays */
+	weekdays(days, errorMessage) {
+		return this.addRule(weekdaysRule, errorMessage, { days });
+	}
+	/** Date must be a weekend (Saturday or Sunday) */
+	weekend(errorMessage) {
+		return this.addRule(weekendRule, errorMessage);
+	}
+	/** Date must be a business day (Monday-Friday) */
+	businessDay(errorMessage) {
+		return this.addRule(businessDayRule, errorMessage);
+	}
+	/** Date must match specific format */
+	format(format, errorMessage) {
+		return this.addRule(dateRule, errorMessage, { format });
+	}
+	/** Date must be within X days from now (past or future) */
+	withinDays(days, errorMessage) {
+		return this.addRule(withinDaysRule, errorMessage, { days });
+	}
+	/** Date must be within X days in the past */
+	withinPastDays(days, errorMessage) {
+		return this.addRule(withinPastDaysRule, errorMessage, { days });
+	}
+	/** Date must be within X days in the future */
+	withinFutureDays(days, errorMessage) {
+		return this.addRule(withinFutureDaysRule, errorMessage, { days });
+	}
+	/** Date must be in specific month (1-12) */
+	month(month, errorMessage) {
+		return this.addRule(monthRule, errorMessage, { month });
+	}
+	/** Date must be in specific year */
+	year(year, errorMessage) {
+		return this.addRule(yearRule, errorMessage, { year });
+	}
+	/**
+	* Date must be between start and end years
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	betweenYears(startYear, endYear, errorMessage) {
+		return this.addRule(betweenYearsRule, errorMessage, {
+			startYear,
+			endYear,
+			scope: "global"
+		});
+	}
+	/**
+	* Date must be between start and end months (1-12)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	betweenMonths(startMonth, endMonth, errorMessage) {
+		return this.addRule(betweenMonthsRule, errorMessage, {
+			startMonth,
+			endMonth,
+			scope: "global"
+		});
+	}
+	/**
+	* Date must be between start and end days (1-31)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	betweenDays(startDay, endDay, errorMessage) {
+		return this.addRule(betweenDaysRule, errorMessage, {
+			startDay,
+			endDay,
+			scope: "global"
+		});
+	}
+	/**
+	* Date must be between sibling field years
+	* @category Validation Rule
+	*/
+	betweenYearsSibling(startYearField, endYearField, errorMessage) {
+		return this.addRule(betweenYearsRule, errorMessage, {
+			startYear: startYearField,
+			endYear: endYearField,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Date must be between sibling field months
+	* @category Validation Rule
+	*/
+	betweenMonthsSibling(startMonthField, endMonthField, errorMessage) {
+		return this.addRule(betweenMonthsRule, errorMessage, {
+			startMonth: startMonthField,
+			endMonth: endMonthField,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Date must be between sibling field days
+	* @category Validation Rule
+	*/
+	betweenDaysSibling(startDayField, endDayField, errorMessage) {
+		return this.addRule(betweenDaysRule, errorMessage, {
+			startDay: startDayField,
+			endDay: endDayField,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Year must be >= given year or field
+	* Smart detection: number or field name
+	*
+	* @example
+	* ```ts
+	* // Value comparison
+	* v.date().minYear(2024)
+	*
+	* // Field comparison
+	* v.date().minYear('startYear')
+	* ```
+	*
+	* @category Validation Rule
+	*/
+	minYear(yearOrField, errorMessage) {
+		return this.addRule(minYearRule, errorMessage, {
+			yearOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Year must be <= given year or field
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	maxYear(yearOrField, errorMessage) {
+		return this.addRule(maxYearRule, errorMessage, {
+			yearOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Month must be >= given month or field (1-12)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	minMonth(monthOrField, errorMessage) {
+		return this.addRule(minMonthRule, errorMessage, {
+			monthOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Month must be <= given month or field (1-12)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	maxMonth(monthOrField, errorMessage) {
+		return this.addRule(maxMonthRule, errorMessage, {
+			monthOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Day must be >= given day or field (1-31)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	minDay(dayOrField, errorMessage) {
+		return this.addRule(minDayRule, errorMessage, {
+			dayOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Day must be <= given day or field (1-31)
+	* Smart detection: number or field name
+	*
+	* @category Validation Rule
+	*/
+	maxDay(dayOrField, errorMessage) {
+		return this.addRule(maxDayRule, errorMessage, {
+			dayOrField,
+			scope: "global"
+		});
+	}
+	/**
+	* Year must be >= sibling field year
+	* @category Validation Rule
+	*/
+	minYearSibling(field, errorMessage) {
+		return this.addRule(minYearRule, errorMessage, {
+			yearOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Year must be <= sibling field year
+	* @category Validation Rule
+	*/
+	maxYearSibling(field, errorMessage) {
+		return this.addRule(maxYearRule, errorMessage, {
+			yearOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Month must be >= sibling field month
+	* @category Validation Rule
+	*/
+	minMonthSibling(field, errorMessage) {
+		return this.addRule(minMonthRule, errorMessage, {
+			monthOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Month must be <= sibling field month
+	* @category Validation Rule
+	*/
+	maxMonthSibling(field, errorMessage) {
+		return this.addRule(maxMonthRule, errorMessage, {
+			monthOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Day must be >= sibling field day
+	* @category Validation Rule
+	*/
+	minDaySibling(field, errorMessage) {
+		return this.addRule(minDayRule, errorMessage, {
+			dayOrField: field,
+			scope: "sibling"
+		});
+	}
+	/**
+	* Day must be <= sibling field day
+	* @category Validation Rule
+	*/
+	maxDaySibling(field, errorMessage) {
+		return this.addRule(maxDayRule, errorMessage, {
+			dayOrField: field,
+			scope: "sibling"
+		});
+	}
+	/** Date must be in specific quarter (1-4) */
+	quarter(quarter, errorMessage) {
+		return this.addRule(quarterRule, errorMessage, { quarter });
+	}
+	/** Valid birthday (not in future, reasonable age) */
+	birthday(minAge, maxAge, errorMessage) {
+		return this.addRule(birthdayRule, errorMessage, {
+			minAge,
+			maxAge
+		});
+	}
+	/** Date must be in a leap year */
+	leapYear(errorMessage) {
+		return this.addRule(leapYearRule, errorMessage);
+	}
+	/**
+	* Set default value as current time of exeuction
+	*/
+	defaultNow() {
+		return this.default(() => /* @__PURE__ */ new Date());
+	}
+	/**
+	* @inheritdoc
+	*
+	* Maps DateValidator to JSON Schema format keywords.
+	* Default is `date-time`. If `.toDateOnly()` or `.toTimeOnly()` are used,
+	* falls back to `date` or `time` formats respectively.
+	*
+	* @example
+	* ```ts
+	* v.date().toJsonSchema("draft-2020-12")
+	* // → { type: "string", format: "date-time" }
+	*
+	* v.date().toDateOnly().toJsonSchema("draft-2020-12")
+	* // → { type: "string", format: "date" }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = {
+			type: "string",
+			format: "date-time"
+		};
+		const dateOpts = getRuleOptions(this.rules, "date");
+		if (dateOpts?.format === "YYYY-MM-DD") schema.format = "date";
+		else if (dateOpts?.format === "HH:mm:ss") schema.format = "time";
+		if (schema.format === "date-time") for (const t of this.dataTransformers) {
+			const hint = t.options?.__jsonSchemaFormat;
+			if (hint === "date" || hint === "time") {
+				schema.format = hint;
+				break;
+			}
+			const userFormat = t.options?.format;
+			if (userFormat === "YYYY-MM-DD") {
+				schema.format = "date";
+				break;
+			}
+			if (userFormat === "HH:mm:ss") {
+				schema.format = "time";
+				break;
+			}
+		}
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { DateValidator };
+//# sourceMappingURL=date-validator.mjs.map