@astral/validations 4.14.6 → 4.15.0

package/README.md

@@ -52,6 +52,10 @@
     - [min](#min-date)
     - [max](#max-date)
     - [minYearsOld](#min-years-old-date)
+    - [rangeDate](#range-date)
+      - [rangeDateInterval](#range-date-interval)
+      - [rangeDateMinMax](#range-date-minmax)
+      - [rangeDateNotEqual](#range-date-notequal)
   - [boolean](#boolean)
   - [object](#object)
     - [partial](#partial)
@@ -989,6 +993,155 @@ validate(new Date('10.10.2005'));
 
 ---
 
+### rangeDate
+
+Проверяет даты интервала на обязательность заполнения, валидность значений и хронологический порядок
+
+```ts
+import { rangeDate } from '@astral/validations';
+
+const validate = rangeDate();
+
+// { message: 'Укажите период' }
+validate({});
+
+// { message: 'Укажите дату окончания' }
+validate({
+  start: new Date('2024.09.05'),
+})
+
+// { message: 'Укажите дату начала' }
+validate({
+  end: new Date('2024.09.24'),
+})
+
+// { message: 'Дата начала некорректная' }
+validate({
+  start: new Date('2024.99.99'),
+  end: new Date('2024.09.24'),
+})
+
+// { message: 'Дата окончания некорректная' }
+validate({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.99.99'),
+})
+
+// { message: 'Дата окончания не может быть раньше даты начала' }
+validate({
+  start: new Date('2024.09.24'),
+  end: new Date('2024.09.05'),
+})
+
+// undefined
+validate({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.09.24'),
+});
+
+```
+
+---
+
+#### rangeDateInterval
+
+Позволяет ограничить интервал на конкретное значение.
+По умолчанию значение интервала задаётся в днях, но с помощью опции unit можно задать значение в месяцах или годах.
+
+```ts
+import { rangeDateInterval } from '@astral/validations';
+
+const validate = object(rangeDateInterval({ limit: 14 }));
+
+// { message: 'Период не может превышать 14 дней' }
+validate({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.09.24'),
+});
+
+// undefined
+validate({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.09.12'),
+});
+
+const validateMonthInterval = object(rangeDateInterval({ limit: 2, unit: 'month' }));
+
+// { message: 'Период не может превышать 2 месяца' }
+validateMonthInterval({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.12.24'),
+});
+
+// undefined
+validateMonthInterval({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.09.12'),
+});
+
+
+```
+
+---
+
+#### rangeDateMinMax
+
+Проверяет даты на минимальное и максимальное допустимое значение
+
+```ts
+import { rangeDateMinMax } from '@astral/validations';
+
+const validate = object(rangeDateMinMax({ start: { min: { limit: new Date('2024.09.05') }}, end: { max: { limit: new Date('2024.09.15') } } }))
+
+// { message: 'Дата начала должна быть позже 05.09.2024' }
+validate({
+  start: new Date('2024.09.01'),
+  end: new Date('2024.09.10'),
+});
+
+// { message: 'Дата окончания должна быть раньше 15.09.2024}' }
+validate({
+  start: new Date('2024.09.06'),
+  end: new Date('2024.09.20'),
+});
+
+// undefined
+validate({
+  start: new Date('2024.09.06'),
+  end: new Date('2024.09.14'),
+});
+
+```
+
+---
+
+#### rangeDateNotEqual
+
+Проверяет даты интервала на совпадение даты начала и окончания
+
+```ts
+import { rangeDateNotEqual } from '@astral/validations';
+
+const validate = object(
+  rangeDateNotEqual(),
+);
+
+// { message: 'Даты начала и окончания не могут совпадать' }
+validate({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.09.05'),
+});
+
+// undefined
+validate({
+  start: new Date('2024.09.05'),
+  end: new Date('2024.09.06'),
+});
+
+```
+
+---
+
 ## boolean
 
 - Возвращает ошибку если:

package/core/utils/index.d.ts

@@ -1,7 +1,8 @@
-export * from './isStringOfZeros';
+export * from './isDateEarlier';
+export * from './isFullNameValidCharacters';
+export * from './isHasConsecutiveChars';
 export * from './isNoDoubleZeroStart';
-export * from './resetTime';
 export * from './isStartsWithAndEndsWithLetter';
-export * from './isHasConsecutiveChars';
-export * from './isFullNameValidCharacters';
+export * from './isStringOfZeros';
 export * from './isValidFullNameLength';
+export * from './resetTime';

package/core/utils/index.js

@@ -1,7 +1,8 @@
-export * from './isStringOfZeros';
+export * from './isDateEarlier';
+export * from './isFullNameValidCharacters';
+export * from './isHasConsecutiveChars';
 export * from './isNoDoubleZeroStart';
-export * from './resetTime';
 export * from './isStartsWithAndEndsWithLetter';
-export * from './isHasConsecutiveChars';
-export * from './isFullNameValidCharacters';
+export * from './isStringOfZeros';
 export * from './isValidFullNameLength';
+export * from './resetTime';

package/core/utils/isDateEarlier/index.d.ts

@@ -0,0 +1 @@
+export * from './isDateEarlier';

package/core/utils/isDateEarlier/index.js

@@ -0,0 +1 @@
+export * from './isDateEarlier';

package/core/utils/isDateEarlier/isDateEarlier.d.ts

@@ -0,0 +1 @@
+export declare const isDateEarlier: (dateA: Date, dateB: Date) => boolean;

package/core/utils/isDateEarlier/isDateEarlier.js

@@ -0,0 +1,4 @@
+import { resetTime } from '../resetTime';
+export const isDateEarlier = (dateA, dateB) => {
+    return resetTime(dateA).getTime() < resetTime(dateB).getTime();
+};

package/index.d.ts

@@ -45,3 +45,7 @@ export { when } from './when';
 export { toPrettyError } from './toPrettyError';
 export { transform } from './transform';
 export { enabled } from './enabled';
+export { rangeDate, RANGE_DATE_END_EARLIER_START_ERROR_INFO, RANGE_DATE_END_INVALID_ERROR_INFO, RANGE_DATE_END_REQUIRED_ERROR_INFO, RANGE_DATE_REQUIRED_ERROR_INFO, RANGE_DATE_START_INVALID_ERROR_INFO, RANGE_DATE_START_REQUIRED_ERROR_INFO, } from './rangeDate';
+export { rangeDateInterval, RANGE_DATE_INTERVAL_ERROR_INFO, } from './rangeDateInterval';
+export { rangeDateMinMax, RANGE_DATE_MAX_ERROR_INFO, RANGE_DATE_MIN_ERROR_INFO, } from './rangeDateMinMax';
+export { rangeDateNotEqual, RANGE_DATE_NOT_EQUAL_ERROR_INFO, } from './rangeDateNotEqual';

package/index.js

@@ -45,3 +45,7 @@ export { when } from './when';
 export { toPrettyError } from './toPrettyError';
 export { transform } from './transform';
 export { enabled } from './enabled';
+export { rangeDate, RANGE_DATE_END_EARLIER_START_ERROR_INFO, RANGE_DATE_END_INVALID_ERROR_INFO, RANGE_DATE_END_REQUIRED_ERROR_INFO, RANGE_DATE_REQUIRED_ERROR_INFO, RANGE_DATE_START_INVALID_ERROR_INFO, RANGE_DATE_START_REQUIRED_ERROR_INFO, } from './rangeDate';
+export { rangeDateInterval, RANGE_DATE_INTERVAL_ERROR_INFO, } from './rangeDateInterval';
+export { rangeDateMinMax, RANGE_DATE_MAX_ERROR_INFO, RANGE_DATE_MIN_ERROR_INFO, } from './rangeDateMinMax';
+export { rangeDateNotEqual, RANGE_DATE_NOT_EQUAL_ERROR_INFO, } from './rangeDateNotEqual';

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@astral/validations",
-  "version": "4.14.6",
+  "version": "4.15.0",
   "browser": "./index.js",
   "main": "./index.js",
   "dependencies": {
     "is-plain-obj": "^4.1.0",
-    "utility-types": "^3.10.0"
+    "utility-types": "^3.10.0",
+    "@astral/utils": "^1.1.0"
   },
   "author": "Astral.Soft",
   "license": "MIT",

package/rangeDate/constants.d.ts

@@ -0,0 +1,7 @@
+import { type ErrorInfo } from '../core';
+export declare const RANGE_DATE_REQUIRED_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_START_REQUIRED_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_END_REQUIRED_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_START_INVALID_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_END_INVALID_ERROR_INFO: ErrorInfo;
+export declare const RANGE_DATE_END_EARLIER_START_ERROR_INFO: ErrorInfo;

package/rangeDate/constants.js

@@ -0,0 +1,25 @@
+import { createErrorCode } from '../core';
+export const RANGE_DATE_REQUIRED_ERROR_INFO = {
+    code: createErrorCode('rangedate-required'),
+    message: 'Укажите период',
+};
+export const RANGE_DATE_START_REQUIRED_ERROR_INFO = {
+    code: createErrorCode('rangedate-startRequired'),
+    message: 'Укажите дату начала',
+};
+export const RANGE_DATE_END_REQUIRED_ERROR_INFO = {
+    code: createErrorCode('rangedate-endRequired'),
+    message: 'Укажите дату окончания',
+};
+export const RANGE_DATE_START_INVALID_ERROR_INFO = {
+    code: createErrorCode('rangedate-startInvalid'),
+    message: 'Дата начала некорректная',
+};
+export const RANGE_DATE_END_INVALID_ERROR_INFO = {
+    code: createErrorCode('rangedate-endInvalid'),
+    message: 'Дата окончания некорректная',
+};
+export const RANGE_DATE_END_EARLIER_START_ERROR_INFO = {
+    code: createErrorCode('rangedate-endEarlierStart'),
+    message: 'Дата окончания не может быть раньше даты начала',
+};

package/rangeDate/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDate';

package/rangeDate/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDate';

package/rangeDate/rangeDate.d.ts

@@ -0,0 +1,48 @@
+type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+type RangeDateParams = {
+    /**
+     * Позволяет пометить дату как необязательная
+     */
+    required?: {
+        /**
+         * Если `false` дата начала будет не обязательна
+         * @default true
+         */
+        start?: boolean;
+        /**
+         * Если `false` дата окончания будет не обязательна
+         * @default true
+         */
+        end?: boolean;
+    };
+    /**
+     * Позволяет переопределить дефолтные сообщения об ошибках
+     */
+    messages?: {
+        /**
+         * Для даты начала
+         */
+        startRequired?: string;
+        /**
+         * Для даты окончания
+         */
+        endRequired?: string;
+        /**
+         * Если дата окончания раньше даты начала
+         */
+        endEarlierStart?: string;
+    };
+};
+/**
+ * Проверяет даты интервала на обязательность заполнения, валидность значений и хронологический порядок
+ * @example
+ * ```ts
+ * const validate = object(rangeDate());
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export declare const rangeDate: <TLastSchemaValues extends Record<string, unknown>>(params?: RangeDateParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/rangeDate/rangeDate.js

@@ -0,0 +1,60 @@
+import { isDate } from '@astral/utils';
+import { createRule, isDateEarlier } from '../core';
+import { RANGE_DATE_END_EARLIER_START_ERROR_INFO, RANGE_DATE_END_INVALID_ERROR_INFO, RANGE_DATE_END_REQUIRED_ERROR_INFO, RANGE_DATE_REQUIRED_ERROR_INFO, RANGE_DATE_START_INVALID_ERROR_INFO, RANGE_DATE_START_REQUIRED_ERROR_INFO, } from './constants';
+/**
+ * Проверяет даты интервала на обязательность заполнения, валидность значений и хронологический порядок
+ * @example
+ * ```ts
+ * const validate = object(rangeDate());
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export const rangeDate = (params) => createRule((value, ctx) => {
+    const { required, messages } = Object.assign(Object.assign({}, (params || {})), { required: {
+            start: (params === null || params === void 0 ? void 0 : params.required) && 'start' in (params === null || params === void 0 ? void 0 : params.required)
+                ? params === null || params === void 0 ? void 0 : params.required.start
+                : true,
+            end: (params === null || params === void 0 ? void 0 : params.required) && 'end' in (params === null || params === void 0 ? void 0 : params.required)
+                ? params === null || params === void 0 ? void 0 : params.required.end
+                : true,
+        } });
+    if ((required === null || required === void 0 ? void 0 : required.start) && (required === null || required === void 0 ? void 0 : required.end) && !value.start && !value.end) {
+        return ctx.createError({
+            message: RANGE_DATE_REQUIRED_ERROR_INFO.message,
+            code: RANGE_DATE_REQUIRED_ERROR_INFO.code,
+        });
+    }
+    if ((required === null || required === void 0 ? void 0 : required.start) && !value.start) {
+        return ctx.createError({
+            message: (messages === null || messages === void 0 ? void 0 : messages.startRequired) ||
+                RANGE_DATE_START_REQUIRED_ERROR_INFO.message,
+            code: RANGE_DATE_START_REQUIRED_ERROR_INFO.code,
+        });
+    }
+    if ((required === null || required === void 0 ? void 0 : required.end) && !value.end) {
+        return ctx.createError({
+            message: (messages === null || messages === void 0 ? void 0 : messages.endRequired) || RANGE_DATE_END_REQUIRED_ERROR_INFO.message,
+            code: RANGE_DATE_END_REQUIRED_ERROR_INFO.code,
+        });
+    }
+    if ((value === null || value === void 0 ? void 0 : value.start) && !isDate(value.start)) {
+        return ctx.createError({
+            message: RANGE_DATE_START_INVALID_ERROR_INFO.message,
+            code: RANGE_DATE_START_INVALID_ERROR_INFO.code,
+        });
+    }
+    if ((value === null || value === void 0 ? void 0 : value.end) && !isDate(value.end)) {
+        return ctx.createError({
+            message: RANGE_DATE_END_INVALID_ERROR_INFO.message,
+            code: RANGE_DATE_END_INVALID_ERROR_INFO.code,
+        });
+    }
+    if (value.end && value.start && isDateEarlier(value.end, value.start)) {
+        return ctx.createError({
+            message: (messages === null || messages === void 0 ? void 0 : messages.endEarlierStart) ||
+                RANGE_DATE_END_EARLIER_START_ERROR_INFO.message,
+            code: RANGE_DATE_END_EARLIER_START_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});

package/rangeDateInterval/constants.d.ts

@@ -0,0 +1,7 @@
+import { type ErrorInfo } from '../core';
+import type { DefaultMessage } from './types';
+type DynamicErrorInfo = Pick<ErrorInfo, 'code'> & {
+    message: DefaultMessage;
+};
+export declare const RANGE_DATE_INTERVAL_ERROR_INFO: DynamicErrorInfo;
+export {};

package/rangeDateInterval/constants.js

@@ -0,0 +1,14 @@
+import { declensionDay, declensionMonth, declensionYear } from '@astral/utils';
+import { createErrorCode } from '../core';
+const selectDeclensionUnitStrategy = (unit) => {
+    const strategy = {
+        day: declensionDay,
+        month: declensionMonth,
+        year: declensionYear,
+    };
+    return strategy[unit];
+};
+export const RANGE_DATE_INTERVAL_ERROR_INFO = {
+    code: createErrorCode('rangedate-interval'),
+    message: (limit, unit) => `Период не может превышать ${limit} ${selectDeclensionUnitStrategy(unit)(limit)}`,
+};

package/rangeDateInterval/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDateInterval';

package/rangeDateInterval/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDateInterval';

package/rangeDateInterval/rangeDateInterval.d.ts

@@ -0,0 +1,23 @@
+import type { DateUnit, RangeDateValue } from './types';
+type RangeDateIntervalParams = {
+    limit: number;
+    /**
+     * Еденицы измерения лимита
+     * @default 'day'
+     */
+    unit?: DateUnit;
+    /**
+     * Замена стандартного сообщения об ошибки
+     */
+    message?: string;
+};
+/**
+ * Позволяет ограничить интервал на конкретное значение. Установка интревала возможна в следующих единицах: день, месяц и год.
+ * @example
+ * ```ts
+ * const validate = object(rangeDateInterval({ limit: 14 }));
+ * validate({ start: new Date('2024.08.15'), end: new Date('2024.09.05') });
+ * ```
+ */
+export declare const rangeDateInterval: <TLastSchemaValues extends Record<string, unknown>>(params: RangeDateIntervalParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/rangeDateInterval/rangeDateInterval.js

@@ -0,0 +1,36 @@
+import { addDays, addMonths, addYears, isDate } from '@astral/utils';
+import { createRule, isDateEarlier } from '../core';
+import { RANGE_DATE_INTERVAL_ERROR_INFO } from './constants';
+const selectAddingStrategy = (unit) => {
+    const strategy = {
+        day: addDays,
+        month: addMonths,
+        year: addYears,
+    };
+    return strategy[unit];
+};
+/**
+ * Позволяет ограничить интервал на конкретное значение. Установка интревала возможна в следующих единицах: день, месяц и год.
+ * @example
+ * ```ts
+ * const validate = object(rangeDateInterval({ limit: 14 }));
+ * validate({ start: new Date('2024.08.15'), end: new Date('2024.09.05') });
+ * ```
+ */
+export const rangeDateInterval = (params) => createRule((value, ctx) => {
+    const { limit, unit = 'day', message } = params;
+    if (!value.start || !value.end) {
+        return undefined;
+    }
+    if (!isDate(value.start) || !isDate(value.end)) {
+        return undefined;
+    }
+    const addLimits = selectAddingStrategy(unit);
+    if (!isDateEarlier(value.end, addLimits(value.start, limit))) {
+        return ctx.createError({
+            message: message || RANGE_DATE_INTERVAL_ERROR_INFO.message(limit, unit),
+            code: RANGE_DATE_INTERVAL_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});

package/rangeDateInterval/types.d.ts

@@ -0,0 +1,6 @@
+export type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+export type DateUnit = 'day' | 'month' | 'year';
+export type DefaultMessage = (limit: number, unit: DateUnit) => string;

package/rangeDateInterval/types.js

@@ -0,0 +1 @@
+export {};

package/rangeDateMinMax/constants.d.ts

@@ -0,0 +1,8 @@
+import { type ErrorInfo } from '../core';
+import type { DefaultMessage } from './types';
+type DynamicErrorInfo = Pick<ErrorInfo, 'code'> & {
+    message: DefaultMessage;
+};
+export declare const RANGE_DATE_MIN_ERROR_INFO: DynamicErrorInfo;
+export declare const RANGE_DATE_MAX_ERROR_INFO: DynamicErrorInfo;
+export {};

package/rangeDateMinMax/constants.js

@@ -0,0 +1,13 @@
+import { createErrorCode } from '../core';
+const DEFAULT_FIELD_NAME = {
+    start: 'начала',
+    end: 'окончания',
+};
+export const RANGE_DATE_MIN_ERROR_INFO = {
+    code: createErrorCode('rangedate-min'),
+    message: (field, minDate) => `Дата ${DEFAULT_FIELD_NAME[field]} должна быть позже ${minDate}`,
+};
+export const RANGE_DATE_MAX_ERROR_INFO = {
+    code: createErrorCode('rangedate-max'),
+    message: (field, maxDate) => `Дата ${DEFAULT_FIELD_NAME[field]} должна быть раньше ${maxDate}`,
+};

package/rangeDateMinMax/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDateMinMax';

package/rangeDateMinMax/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDateMinMax';

package/rangeDateMinMax/rangeDateMinMax.d.ts

@@ -0,0 +1,34 @@
+type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+type LimitOptions = {
+    /**
+     * Дата
+     */
+    limit: Date;
+    /**
+     * Замена стандартного сообщения ошибки
+     */
+    message?: (field: 'start' | 'end', date: string) => string;
+};
+type RangeDateMinMaxParams = {
+    start?: {
+        min?: LimitOptions;
+        max?: LimitOptions;
+    };
+    end?: {
+        min?: LimitOptions;
+        max?: LimitOptions;
+    };
+};
+/**
+ * Проверяет даты на минимальное и максимальное допустимое значение
+ * @example
+ * ```ts
+ * const validate = object(rangeDateMinMax({ start: { min: { limit: new Date(2023, 0, 1) }}, end: { max: { limit: new Date() } } }));
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export declare const rangeDateMinMax: <TLastSchemaValues extends Record<string, unknown>>(params?: RangeDateMinMaxParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/rangeDateMinMax/rangeDateMinMax.js

@@ -0,0 +1,74 @@
+import { isDate } from '@astral/utils';
+import { createRule, isDateEarlier } from '../core';
+import { RANGE_DATE_END_INVALID_ERROR_INFO, RANGE_DATE_START_INVALID_ERROR_INFO, } from '../rangeDate';
+import { RANGE_DATE_MAX_ERROR_INFO, RANGE_DATE_MIN_ERROR_INFO, } from './constants';
+const formatDateToView = (date) => {
+    return new Intl.DateTimeFormat('ru-RU').format(date);
+};
+/**
+ * Проверяет даты на минимальное и максимальное допустимое значение
+ * @example
+ * ```ts
+ * const validate = object(rangeDateMinMax({ start: { min: { limit: new Date(2023, 0, 1) }}, end: { max: { limit: new Date() } } }));
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export const rangeDateMinMax = (params) => createRule((value, ctx) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+    if (!value.start && !value.end) {
+        return undefined;
+    }
+    if ((value === null || value === void 0 ? void 0 : value.start) && !isDate(value.start)) {
+        return ctx.createError({
+            message: RANGE_DATE_START_INVALID_ERROR_INFO.message,
+            code: RANGE_DATE_START_INVALID_ERROR_INFO.code,
+        });
+    }
+    if ((value === null || value === void 0 ? void 0 : value.end) && !isDate(value.end)) {
+        return ctx.createError({
+            message: RANGE_DATE_END_INVALID_ERROR_INFO.message,
+            code: RANGE_DATE_END_INVALID_ERROR_INFO.code,
+        });
+    }
+    // Если дата начала раньше заданной минимальной
+    if (((_b = (_a = params === null || params === void 0 ? void 0 : params.start) === null || _a === void 0 ? void 0 : _a.min) === null || _b === void 0 ? void 0 : _b.limit) &&
+        value.start &&
+        isDateEarlier(value.start, (_c = params === null || params === void 0 ? void 0 : params.start.min) === null || _c === void 0 ? void 0 : _c.limit)) {
+        return ctx.createError({
+            message: ((_e = (_d = params.start.min).message) === null || _e === void 0 ? void 0 : _e.call(_d, 'start', formatDateToView(params.start.min.limit))) ||
+                RANGE_DATE_MIN_ERROR_INFO.message('start', formatDateToView(params.start.min.limit)),
+            code: RANGE_DATE_MIN_ERROR_INFO.code,
+        });
+    }
+    // Если дата начала позже заданной максимальной
+    if (((_g = (_f = params === null || params === void 0 ? void 0 : params.start) === null || _f === void 0 ? void 0 : _f.max) === null || _g === void 0 ? void 0 : _g.limit) &&
+        value.start &&
+        isDateEarlier((_h = params === null || params === void 0 ? void 0 : params.start.max) === null || _h === void 0 ? void 0 : _h.limit, value.start)) {
+        return ctx.createError({
+            message: ((_k = (_j = params.start.max).message) === null || _k === void 0 ? void 0 : _k.call(_j, 'start', formatDateToView(params.start.max.limit))) ||
+                RANGE_DATE_MAX_ERROR_INFO.message('start', formatDateToView(params.start.max.limit)),
+            code: RANGE_DATE_MAX_ERROR_INFO.code,
+        });
+    }
+    // Если дата окончания раньше заданной минимальной
+    if (((_m = (_l = params === null || params === void 0 ? void 0 : params.end) === null || _l === void 0 ? void 0 : _l.min) === null || _m === void 0 ? void 0 : _m.limit) &&
+        value.end &&
+        isDateEarlier(value.end, (_o = params === null || params === void 0 ? void 0 : params.end.min) === null || _o === void 0 ? void 0 : _o.limit)) {
+        return ctx.createError({
+            message: ((_q = (_p = params.end.min).message) === null || _q === void 0 ? void 0 : _q.call(_p, 'start', formatDateToView(params.end.min.limit))) ||
+                RANGE_DATE_MIN_ERROR_INFO.message('end', formatDateToView(params.end.min.limit)),
+            code: RANGE_DATE_MIN_ERROR_INFO.code,
+        });
+    }
+    // Если дата окончания позже заданной максимально
+    if (((_s = (_r = params === null || params === void 0 ? void 0 : params.end) === null || _r === void 0 ? void 0 : _r.max) === null || _s === void 0 ? void 0 : _s.limit) &&
+        value.end &&
+        isDateEarlier((_t = params === null || params === void 0 ? void 0 : params.end.max) === null || _t === void 0 ? void 0 : _t.limit, value.end)) {
+        return ctx.createError({
+            message: ((_v = (_u = params.end.max).message) === null || _v === void 0 ? void 0 : _v.call(_u, 'start', formatDateToView(params.end.max.limit))) ||
+                RANGE_DATE_MAX_ERROR_INFO.message('end', formatDateToView(params.end.max.limit)),
+            code: RANGE_DATE_MAX_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});

package/rangeDateMinMax/types.d.ts

@@ -0,0 +1,2 @@
+export type Field = 'start' | 'end';
+export type DefaultMessage = (field: Field, date: string) => string;

package/rangeDateMinMax/types.js

@@ -0,0 +1 @@
+export {};

package/rangeDateNotEqual/constants.d.ts

@@ -0,0 +1,2 @@
+import { type ErrorInfo } from '../core';
+export declare const RANGE_DATE_NOT_EQUAL_ERROR_INFO: ErrorInfo;

package/rangeDateNotEqual/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const RANGE_DATE_NOT_EQUAL_ERROR_INFO = {
+    code: createErrorCode('rangedate-notequal'),
+    message: 'Даты начала и окончания не могут совпадать',
+};

package/rangeDateNotEqual/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDateNotEqual';

package/rangeDateNotEqual/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './rangeDateNotEqual';

package/rangeDateNotEqual/rangeDateNotEqual.d.ts

@@ -0,0 +1,20 @@
+type RangeDateValue = {
+    start?: Date;
+    end?: Date;
+};
+type RangeDateNotEqualParams = {
+    /**
+     * Замена стандартного сообщения ошибки
+     */
+    message?: string;
+};
+/**
+ * Проверяет даты интервала на совпадение даты начала и окончания
+ * @example
+ * ```ts
+ * const validate = object(rangeDateNotEqual());
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export declare const rangeDateNotEqual: <TLastSchemaValues extends Record<string, unknown>>(params?: RangeDateNotEqualParams) => (value: RangeDateValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/rangeDateNotEqual/rangeDateNotEqual.js

@@ -0,0 +1,29 @@
+import { isDate } from '@astral/utils';
+import { createRule, resetTime } from '../core';
+import { RANGE_DATE_NOT_EQUAL_ERROR_INFO } from './constants';
+const isDateEqual = (dateA, dateB) => {
+    return resetTime(dateA).getTime() === resetTime(dateB).getTime();
+};
+/**
+ * Проверяет даты интервала на совпадение даты начала и окончания
+ * @example
+ * ```ts
+ * const validate = object(rangeDateNotEqual());
+ * validate({ start: new Date(), end: new Date() });
+ * ```
+ */
+export const rangeDateNotEqual = (params) => createRule((value, ctx) => {
+    if (!value.start || !value.end) {
+        return undefined;
+    }
+    if (!isDate(value.start) || !isDate(value.end)) {
+        return undefined;
+    }
+    if (isDateEqual(value.start, value.end)) {
+        return ctx.createError({
+            message: (params === null || params === void 0 ? void 0 : params.message) || RANGE_DATE_NOT_EQUAL_ERROR_INFO.message,
+            code: RANGE_DATE_NOT_EQUAL_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});