@warlock.js/notifications 5.31.0 → 5.32.0

package/esm/packages/seal/src/validators/date-validator.mjs

@@ -1,640 +0,0 @@
-import { __toESM } from "../../../../_virtual/_rolldown/runtime.mjs";
-import { applyNullable, getRuleOptions } from "../standard-schema/json-schema.mjs";
-import { isDateValue } from "../helpers/date-helpers.mjs";
-import { BaseValidator } from "./base-validator.mjs";
-import { require_dayjs_min } from "../../../../node_modules/.pnpm/dayjs@1.11.23/node_modules/dayjs/dayjs.min.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";
-
-//#region ../../packages/seal/src/validators/date-validator.ts
-var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
-/**
-* Date validator class
-*/
-var DateValidator = class extends BaseValidator {
-	constructor(errorMessage) {
-		super();
-		this.blankIsMissing = true;
-		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 ? (0, import_dayjs_min.default)(data).format(options.format) : data, { format });
-	}
-	/** Convert to date only (remove time, returns YYYY-MM-DD) */
-	toDateOnly() {
-		return this.addTransformer((data) => data instanceof Date ? (0, import_dayjs_min.default)(data).format("YYYY-MM-DD") : data, { __jsonSchemaFormat: "date" });
-	}
-	/** Convert to time only (returns HH:MM:SS) */
-	toTimeOnly() {
-		return this.addTransformer((data) => data instanceof Date ? (0, import_dayjs_min.default)(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