@warlock.js/seal 4.0.135 → 4.0.136

package/cjs/validators/date-validator.js

@@ -4,8 +4,8 @@
 class DateValidator extends baseValidator.BaseValidator {
     constructor(errorMessage) {
         super();
-        this.addMutator(dateMutators.dateMutator); // Normalize to Date object first
-        this.addRule(date.dateRule, errorMessage);
+        this.addMutableMutator(dateMutators.dateMutator); // Normalize to Date object first
+        this.addMutableRule(date.dateRule, errorMessage);
     }
     /**
      * Check if value is a Date type
@@ -20,30 +20,25 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category transformer
      */
     toISOString() {
-        this.addTransformer(data => data instanceof Date ? data.toISOString() : data);
-        return this;
+        return this.addTransformer((data) => (data instanceof Date ? data.toISOString() : data));
     }
     /** Convert date to Unix timestamp (milliseconds) */
     toTimestamp() {
-        this.addTransformer(data => (data instanceof Date ? data.getTime() : data));
-        return this;
+        return this.addTransformer((data) => (data instanceof Date ? data.getTime() : data));
     }
     // ==================== String Format Transformers ====================
     // These convert Date to formatted strings after validation
     /** Convert date to specific format using dayjs */
     toFormat(format) {
-        this.addTransformer((data, { options }) => data instanceof Date ? dayjs__default.default(data).format(options.format) : data, { format });
-        return this;
+        return this.addTransformer((data, { options }) => (data instanceof Date ? dayjs__default.default(data).format(options.format) : data), { format });
     }
     /** Convert to date only (remove time, returns YYYY-MM-DD) */
     toDateOnly() {
-        this.addTransformer(data => data instanceof Date ? dayjs__default.default(data).format("YYYY-MM-DD") : data);
-        return this;
+        return this.addTransformer((data) => data instanceof Date ? dayjs__default.default(data).format("YYYY-MM-DD") : data);
     }
     /** Convert to time only (returns HH:MM:SS) */
     toTimeOnly() {
-        this.addTransformer(data => data instanceof Date ? dayjs__default.default(data).format("HH:mm:ss") : data);
-        return this;
+        return this.addTransformer((data) => data instanceof Date ? dayjs__default.default(data).format("HH:mm:ss") : data);
     }
     // ==================== Date Mutators ====================
     // These modify the Date object before validation
@@ -52,59 +47,48 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category mutator
      */
     toStartOfDay() {
-        this.addMutator(dateMutators.toStartOfDayMutator);
-        return this;
+        return this.addMutator(dateMutators.toStartOfDayMutator);
     }
     /** Convert date to end of day (23:59:59.999) */
     toEndOfDay() {
-        this.addMutator(dateMutators.toEndOfDayMutator);
-        return this;
+        return this.addMutator(dateMutators.toEndOfDayMutator);
     }
     /** Add or subtract days from date */
     addDays(days) {
-        this.addMutator(dateMutators.addDaysMutator, { days });
-        return this;
+        return this.addMutator(dateMutators.addDaysMutator, { days });
     }
     /** Add or subtract months from date */
     addMonths(months) {
-        this.addMutator(dateMutators.addMonthsMutator, { months });
-        return this;
+        return this.addMutator(dateMutators.addMonthsMutator, { months });
     }
     /** Add or subtract years from date */
     addYears(years) {
-        this.addMutator(dateMutators.addYearsMutator, { years });
-        return this;
+        return this.addMutator(dateMutators.addYearsMutator, { years });
     }
     /** Add or subtract hours from date */
     addHours(hours) {
-        this.addMutator(dateMutators.addHoursMutator, { hours });
-        return this;
+        return this.addMutator(dateMutators.addHoursMutator, { hours });
     }
     /** Convert date to UTC */
     toUTC() {
-        this.addMutator(dateMutators.toUTCMutator);
-        return this;
+        return this.addMutator(dateMutators.toUTCMutator);
     }
     // ==================== Date Range Mutators ====================
     /** Set to start of month */
     toStartOfMonth() {
-        this.addMutator(dateMutators.toStartOfMonthMutator);
-        return this;
+        return this.addMutator(dateMutators.toStartOfMonthMutator);
     }
     /** Set to end of month */
     toEndOfMonth() {
-        this.addMutator(dateMutators.toEndOfMonthMutator);
-        return this;
+        return this.addMutator(dateMutators.toEndOfMonthMutator);
     }
     /** Set to start of year */
     toStartOfYear() {
-        this.addMutator(dateMutators.toStartOfYearMutator);
-        return this;
+        return this.addMutator(dateMutators.toStartOfYearMutator);
     }
     /** Set to end of year */
     toEndOfYear() {
-        this.addMutator(dateMutators.toEndOfYearMutator);
-        return this;
+        return this.addMutator(dateMutators.toEndOfYearMutator);
     }
     // ==================== Date Comparison ====================
     /**
@@ -130,10 +114,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     min(dateOrField, errorMessage) {
-        const rule = this.addRule(date.minDateRule, errorMessage);
-        rule.context.options.dateOrField = dateOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(date.minDateRule, errorMessage, {
+            dateOrField,
+            scope: "global",
+        });
     }
     /**
      * Date must be less than or equal to the given date or field (inclusive)
@@ -145,10 +129,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     max(dateOrField, errorMessage) {
-        const rule = this.addRule(date.maxDateRule, errorMessage);
-        rule.context.options.dateOrField = dateOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(date.maxDateRule, errorMessage, {
+            dateOrField,
+            scope: "global",
+        });
     }
     /**
      * Date must be strictly less than the given date or field (exclusive)
@@ -160,10 +144,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     before(dateOrField, errorMessage) {
-        const rule = this.addRule(dateFieldComparisonRules.beforeFieldRule, errorMessage);
-        rule.context.options.dateOrField = dateOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(dateFieldComparisonRules.beforeFieldRule, errorMessage, {
+            dateOrField,
+            scope: "global",
+        });
     }
     /**
      * Date must be strictly greater than the given date or field (exclusive)
@@ -175,47 +159,38 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     after(dateOrField, errorMessage) {
-        const rule = this.addRule(dateFieldComparisonRules.afterFieldRule, errorMessage);
-        rule.context.options.dateOrField = dateOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(dateFieldComparisonRules.afterFieldRule, errorMessage, {
+            dateOrField,
+            scope: "global",
+        });
     }
     /** Date must be between start and end dates */
     between(startDate, endDate, errorMessage) {
-        const rule = this.addRule(dateComparisonRules.betweenDatesRule, errorMessage);
-        rule.context.options.startDate = startDate;
-        rule.context.options.endDate = endDate;
-        return this;
+        return this.addRule(dateComparisonRules.betweenDatesRule, errorMessage, { startDate, endDate });
     }
     /** Date must be exactly today */
     today(errorMessage) {
-        this.addRule(dateComparisonRules.todayRule, errorMessage);
-        return this;
+        return this.addRule(dateComparisonRules.todayRule, errorMessage);
     }
     /** Date must be today or in the future */
     fromToday(errorMessage) {
-        this.addRule(date.fromTodayRule, errorMessage);
-        return this;
+        return this.addRule(date.fromTodayRule, errorMessage);
     }
     /** Date must be before today */
     beforeToday(errorMessage) {
-        this.addRule(date.beforeTodayRule, errorMessage);
-        return this;
+        return this.addRule(date.beforeTodayRule, errorMessage);
     }
     /** Date must be after today (not including today) */
     afterToday(errorMessage) {
-        this.addRule(dateComparisonRules.afterTodayRule, errorMessage);
-        return this;
+        return this.addRule(dateComparisonRules.afterTodayRule, errorMessage);
     }
     /** Date must be in the past */
     past(errorMessage) {
-        this.addRule(dateComparisonRules.pastRule, errorMessage);
-        return this;
+        return this.addRule(dateComparisonRules.pastRule, errorMessage);
     }
     /** Date must be in the future */
     future(errorMessage) {
-        this.addRule(dateComparisonRules.futureRule, errorMessage);
-        return this;
+        return this.addRule(dateComparisonRules.futureRule, errorMessage);
     }
     // ==================== Sibling Field Comparison ====================
     // Explicit sibling scope methods
@@ -224,187 +199,146 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     minSibling(field, errorMessage) {
-        const rule = this.addRule(date.minDateRule, errorMessage);
-        rule.context.options.dateOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(date.minDateRule, errorMessage, {
+            dateOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Date must be <= sibling field value (inclusive)
      * @category Validation Rule
      */
     maxSibling(field, errorMessage) {
-        const rule = this.addRule(date.maxDateRule, errorMessage);
-        rule.context.options.dateOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(date.maxDateRule, errorMessage, {
+            dateOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Date must be < sibling field value (exclusive)
      * @category Validation Rule
      */
     beforeSibling(field, errorMessage) {
-        const rule = this.addRule(dateFieldComparisonRules.beforeFieldRule, errorMessage);
-        rule.context.options.dateOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(dateFieldComparisonRules.beforeFieldRule, errorMessage, {
+            dateOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Date must be > sibling field value (exclusive)
      * @category Validation Rule
      */
     afterSibling(field, errorMessage) {
-        const rule = this.addRule(dateFieldComparisonRules.afterFieldRule, errorMessage);
-        rule.context.options.dateOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(dateFieldComparisonRules.afterFieldRule, errorMessage, {
+            dateOrField: field,
+            scope: "sibling",
+        });
     }
     /** Date must be the same as another field's date */
     sameAsField(field, errorMessage) {
-        const rule = this.addRule(dateFieldComparisonRules.sameAsFieldDateRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(dateFieldComparisonRules.sameAsFieldDateRule, errorMessage, {
+            field,
+            scope: "global",
+        });
     }
     /** Date must be the same as another sibling field's date */
     sameAsFieldSibling(field, errorMessage) {
-        const rule = this.addRule(dateFieldComparisonRules.sameAsFieldDateRule, errorMessage);
-        rule.context.options.field = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(dateFieldComparisonRules.sameAsFieldDateRule, errorMessage, {
+            field,
+            scope: "sibling",
+        });
     }
     // ==================== Time Validation ====================
     /** Time must be from specific hour onwards (0-23) */
     fromHour(hour, errorMessage) {
-        const rule = this.addRule(date.fromHourRule, errorMessage);
-        rule.context.options.hour = hour;
-        return this;
+        return this.addRule(date.fromHourRule, errorMessage, { hour });
     }
     /** Time must be before specific hour (0-23) */
     beforeHour(hour, errorMessage) {
-        const rule = this.addRule(date.beforeHourRule, errorMessage);
-        rule.context.options.hour = hour;
-        return this;
+        return this.addRule(date.beforeHourRule, errorMessage, { hour });
     }
     /** Time must be between start and end hours (0-23) */
     betweenHours(startHour, endHour, errorMessage) {
-        const rule = this.addRule(date.betweenHoursRule, errorMessage);
-        rule.context.options.startHour = startHour;
-        rule.context.options.endHour = endHour;
-        return this;
+        return this.addRule(date.betweenHoursRule, errorMessage, { startHour, endHour });
     }
     /** Time must be from specific minute onwards (0-59) */
     fromMinute(minute, errorMessage) {
-        const rule = this.addRule(date.fromMinuteRule, errorMessage);
-        rule.context.options.minute = minute;
-        return this;
+        return this.addRule(date.fromMinuteRule, errorMessage, { minute });
     }
     /** Time must be before specific minute (0-59) */
     beforeMinute(minute, errorMessage) {
-        const rule = this.addRule(date.beforeMinuteRule, errorMessage);
-        rule.context.options.minute = minute;
-        return this;
+        return this.addRule(date.beforeMinuteRule, errorMessage, { minute });
     }
     /** Time must be between start and end minutes (0-59) */
     betweenMinutes(startMinute, endMinute, errorMessage) {
-        const rule = this.addRule(date.betweenMinutesRule, errorMessage);
-        rule.context.options.startMinute = startMinute;
-        rule.context.options.endMinute = endMinute;
-        return this;
+        return this.addRule(date.betweenMinutesRule, errorMessage, {
+            startMinute,
+            endMinute,
+        });
     }
     /** Time must be between start and end times (HH:MM format) */
     betweenTimes(startTime, endTime, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenTimesRule, errorMessage);
-        rule.context.options.startTime = startTime;
-        rule.context.options.endTime = endTime;
-        return this;
+        return this.addRule(datePeriodRules.betweenTimesRule, errorMessage, { startTime, endTime });
     }
     // ==================== Age Validation ====================
     /** Age must be exactly the given years */
     age(years, errorMessage) {
-        const rule = this.addRule(date.ageRule, errorMessage);
-        rule.context.options.years = years;
-        return this;
+        return this.addRule(date.ageRule, errorMessage, { years });
     }
     /** Minimum age requirement */
     minAge(years, errorMessage) {
-        const rule = this.addRule(date.minAgeRule, errorMessage);
-        rule.context.options.years = years;
-        return this;
+        return this.addRule(date.minAgeRule, errorMessage, { years });
     }
     /** Maximum age requirement */
     maxAge(years, errorMessage) {
-        const rule = this.addRule(date.maxAgeRule, errorMessage);
-        rule.context.options.years = years;
-        return this;
+        return this.addRule(date.maxAgeRule, errorMessage, { years });
     }
     /** Age must be between min and max years */
     betweenAge(minAge, maxAge, errorMessage) {
-        const rule = this.addRule(dateSpecialRules.betweenAgeRule, errorMessage);
-        rule.context.options.minAge = minAge;
-        rule.context.options.maxAge = maxAge;
-        return this;
+        return this.addRule(dateSpecialRules.betweenAgeRule, errorMessage, { minAge, maxAge });
     }
     // ==================== Day Validation ====================
     /** Date must be specific weekday */
     weekDay(day, errorMessage) {
-        const rule = this.addRule(date.weekDayRule, errorMessage);
-        rule.context.options.day = day;
-        return this;
+        return this.addRule(date.weekDayRule, errorMessage, { day });
     }
     /** Date must be one of specified weekdays */
     weekdays(days, errorMessage) {
-        const rule = this.addRule(dateDayRules.weekdaysRule, errorMessage);
-        rule.context.options.days = days;
-        return this;
+        return this.addRule(dateDayRules.weekdaysRule, errorMessage, { days });
     }
     /** Date must be a weekend (Saturday or Sunday) */
     weekend(errorMessage) {
-        this.addRule(dateDayRules.weekendRule, errorMessage);
-        return this;
+        return this.addRule(dateDayRules.weekendRule, errorMessage);
     }
     /** Date must be a business day (Monday-Friday) */
     businessDay(errorMessage) {
-        this.addRule(dateDayRules.businessDayRule, errorMessage);
-        return this;
+        return this.addRule(dateDayRules.businessDayRule, errorMessage);
     }
     /** Date must match specific format */
     format(format, errorMessage) {
-        const rule = this.addRule(date.dateRule, errorMessage);
-        rule.context.options.format = format;
-        return this;
+        return this.addRule(date.dateRule, errorMessage, { format });
     }
     // ==================== Relative Date Validation ====================
     /** Date must be within X days from now (past or future) */
     withinDays(days, errorMessage) {
-        const rule = this.addRule(dateRelativeRules.withinDaysRule, errorMessage);
-        rule.context.options.days = days;
-        return this;
+        return this.addRule(dateRelativeRules.withinDaysRule, errorMessage, { days });
     }
     /** Date must be within X days in the past */
     withinPastDays(days, errorMessage) {
-        const rule = this.addRule(dateRelativeRules.withinPastDaysRule, errorMessage);
-        rule.context.options.days = days;
-        return this;
+        return this.addRule(dateRelativeRules.withinPastDaysRule, errorMessage, { days });
     }
     /** Date must be within X days in the future */
     withinFutureDays(days, errorMessage) {
-        const rule = this.addRule(dateRelativeRules.withinFutureDaysRule, errorMessage);
-        rule.context.options.days = days;
-        return this;
+        return this.addRule(dateRelativeRules.withinFutureDaysRule, errorMessage, { days });
     }
     // ==================== Period Validation ====================
     /** Date must be in specific month (1-12) */
     month(month, errorMessage) {
-        const rule = this.addRule(datePeriodRules.monthRule, errorMessage);
-        rule.context.options.month = month;
-        return this;
+        return this.addRule(datePeriodRules.monthRule, errorMessage, { month });
     }
     /** Date must be in specific year */
     year(year, errorMessage) {
-        const rule = this.addRule(datePeriodRules.yearRule, errorMessage);
-        rule.context.options.year = year;
-        return this;
+        return this.addRule(datePeriodRules.yearRule, errorMessage, { year });
     }
     /**
      * Date must be between start and end years
@@ -413,11 +347,11 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     betweenYears(startYear, endYear, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenYearsRule, errorMessage);
-        rule.context.options.startYear = startYear;
-        rule.context.options.endYear = endYear;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.betweenYearsRule, errorMessage, {
+            startYear,
+            endYear,
+            scope: "global",
+        });
     }
     /**
      * Date must be between start and end months (1-12)
@@ -426,11 +360,11 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     betweenMonths(startMonth, endMonth, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenMonthsRule, errorMessage);
-        rule.context.options.startMonth = startMonth;
-        rule.context.options.endMonth = endMonth;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.betweenMonthsRule, errorMessage, {
+            startMonth,
+            endMonth,
+            scope: "global",
+        });
     }
     /**
      * Date must be between start and end days (1-31)
@@ -439,44 +373,44 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     betweenDays(startDay, endDay, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenDaysRule, errorMessage);
-        rule.context.options.startDay = startDay;
-        rule.context.options.endDay = endDay;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.betweenDaysRule, errorMessage, {
+            startDay,
+            endDay,
+            scope: "global",
+        });
     }
     /**
      * Date must be between sibling field years
      * @category Validation Rule
      */
     betweenYearsSibling(startYearField, endYearField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenYearsRule, errorMessage);
-        rule.context.options.startYear = startYearField;
-        rule.context.options.endYear = endYearField;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.betweenYearsRule, errorMessage, {
+            startYear: startYearField,
+            endYear: endYearField,
+            scope: "sibling",
+        });
     }
     /**
      * Date must be between sibling field months
      * @category Validation Rule
      */
     betweenMonthsSibling(startMonthField, endMonthField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenMonthsRule, errorMessage);
-        rule.context.options.startMonth = startMonthField;
-        rule.context.options.endMonth = endMonthField;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.betweenMonthsRule, errorMessage, {
+            startMonth: startMonthField,
+            endMonth: endMonthField,
+            scope: "sibling",
+        });
     }
     /**
      * Date must be between sibling field days
      * @category Validation Rule
      */
     betweenDaysSibling(startDayField, endDayField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.betweenDaysRule, errorMessage);
-        rule.context.options.startDay = startDayField;
-        rule.context.options.endDay = endDayField;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.betweenDaysRule, errorMessage, {
+            startDay: startDayField,
+            endDay: endDayField,
+            scope: "sibling",
+        });
     }
     /**
      * Year must be >= given year or field
@@ -494,10 +428,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     minYear(yearOrField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.minYearRule, errorMessage);
-        rule.context.options.yearOrField = yearOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.minYearRule, errorMessage, {
+            yearOrField,
+            scope: "global",
+        });
     }
     /**
      * Year must be <= given year or field
@@ -506,10 +440,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     maxYear(yearOrField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.maxYearRule, errorMessage);
-        rule.context.options.yearOrField = yearOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.maxYearRule, errorMessage, {
+            yearOrField,
+            scope: "global",
+        });
     }
     /**
      * Month must be >= given month or field (1-12)
@@ -518,10 +452,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     minMonth(monthOrField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.minMonthRule, errorMessage);
-        rule.context.options.monthOrField = monthOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.minMonthRule, errorMessage, {
+            monthOrField,
+            scope: "global",
+        });
     }
     /**
      * Month must be <= given month or field (1-12)
@@ -530,10 +464,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     maxMonth(monthOrField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.maxMonthRule, errorMessage);
-        rule.context.options.monthOrField = monthOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.maxMonthRule, errorMessage, {
+            monthOrField,
+            scope: "global",
+        });
     }
     /**
      * Day must be >= given day or field (1-31)
@@ -542,10 +476,10 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     minDay(dayOrField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.minDayRule, errorMessage);
-        rule.context.options.dayOrField = dayOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.minDayRule, errorMessage, {
+            dayOrField,
+            scope: "global",
+        });
     }
     /**
      * Day must be <= given day or field (1-31)
@@ -554,92 +488,88 @@ class DateValidator extends baseValidator.BaseValidator {
      * @category Validation Rule
      */
     maxDay(dayOrField, errorMessage) {
-        const rule = this.addRule(datePeriodRules.maxDayRule, errorMessage);
-        rule.context.options.dayOrField = dayOrField;
-        rule.context.options.scope = "global";
-        return this;
+        return this.addRule(datePeriodRules.maxDayRule, errorMessage, {
+            dayOrField,
+            scope: "global",
+        });
     }
     /**
      * Year must be >= sibling field year
      * @category Validation Rule
      */
     minYearSibling(field, errorMessage) {
-        const rule = this.addRule(datePeriodRules.minYearRule, errorMessage);
-        rule.context.options.yearOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.minYearRule, errorMessage, {
+            yearOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Year must be <= sibling field year
      * @category Validation Rule
      */
     maxYearSibling(field, errorMessage) {
-        const rule = this.addRule(datePeriodRules.maxYearRule, errorMessage);
-        rule.context.options.yearOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.maxYearRule, errorMessage, {
+            yearOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Month must be >= sibling field month
      * @category Validation Rule
      */
     minMonthSibling(field, errorMessage) {
-        const rule = this.addRule(datePeriodRules.minMonthRule, errorMessage);
-        rule.context.options.monthOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.minMonthRule, errorMessage, {
+            monthOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Month must be <= sibling field month
      * @category Validation Rule
      */
     maxMonthSibling(field, errorMessage) {
-        const rule = this.addRule(datePeriodRules.maxMonthRule, errorMessage);
-        rule.context.options.monthOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.maxMonthRule, errorMessage, {
+            monthOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Day must be >= sibling field day
      * @category Validation Rule
      */
     minDaySibling(field, errorMessage) {
-        const rule = this.addRule(datePeriodRules.minDayRule, errorMessage);
-        rule.context.options.dayOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.minDayRule, errorMessage, {
+            dayOrField: field,
+            scope: "sibling",
+        });
     }
     /**
      * Day must be <= sibling field day
      * @category Validation Rule
      */
     maxDaySibling(field, errorMessage) {
-        const rule = this.addRule(datePeriodRules.maxDayRule, errorMessage);
-        rule.context.options.dayOrField = field;
-        rule.context.options.scope = "sibling";
-        return this;
+        return this.addRule(datePeriodRules.maxDayRule, errorMessage, {
+            dayOrField: field,
+            scope: "sibling",
+        });
     }
     /** Date must be in specific quarter (1-4) */
     quarter(quarter, errorMessage) {
-        const rule = this.addRule(datePeriodRules.quarterRule, errorMessage);
-        rule.context.options.quarter = quarter;
-        return this;
+        return this.addRule(datePeriodRules.quarterRule, errorMessage, { quarter });
     }
     // ==================== Special Validation ====================
     /** Valid birthday (not in future, reasonable age) */
     birthday(minAge, maxAge, errorMessage) {
-        const rule = this.addRule(dateSpecialRules.birthdayRule, errorMessage);
-        if (minAge !== undefined) {
-            rule.context.options.minAge = minAge;
-        }
-        if (maxAge !== undefined) {
-            rule.context.options.maxAge = maxAge;
-        }
-        return this;
+        return this.addRule(dateSpecialRules.birthdayRule, errorMessage, { minAge, maxAge });
     }
     /** Date must be in a leap year */
     leapYear(errorMessage) {
-        this.addRule(dateSpecialRules.leapYearRule, errorMessage);
-        return this;
+        return this.addRule(dateSpecialRules.leapYearRule, errorMessage);
+    }
+    /**
+     * Set default value as current time of exeuction
+     */
+    defaultNow() {
+        return this.default(() => new Date());
     }
 }exports.DateValidator=DateValidator;//# sourceMappingURL=date-validator.js.map