@oneluiz/dual-datepicker 3.3.0 → 3.5.0

package/esm2022/core/range.validator.mjs

@@ -0,0 +1,105 @@
+/**
+ * Pure validation functions for date ranges
+ * No dependencies, no side effects - just logic
+ * Perfect for SSR, testing, and reusability
+ */
+/**
+ * Validate that end date is not before start date
+ */
+export function validateRangeOrder(start, end) {
+    if (!start || !end) {
+        return { valid: true }; // Allow incomplete selection
+    }
+    if (end < start) {
+        return {
+            valid: false,
+            error: 'End date cannot be before start date'
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate that date is within min/max bounds
+ */
+export function validateDateBounds(date, minDate, maxDate) {
+    if (!date) {
+        return { valid: true };
+    }
+    if (minDate && date < minDate) {
+        return {
+            valid: false,
+            error: `Date cannot be before ${minDate.toISOString().split('T')[0]}`
+        };
+    }
+    if (maxDate && date > maxDate) {
+        return {
+            valid: false,
+            error: `Date cannot be after ${maxDate.toISOString().split('T')[0]}`
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate that a range is within bounds
+ */
+export function validateRangeBounds(start, end, minDate, maxDate) {
+    const startValidation = validateDateBounds(start, minDate, maxDate);
+    if (!startValidation.valid) {
+        return startValidation;
+    }
+    const endValidation = validateDateBounds(end, minDate, maxDate);
+    if (!endValidation.valid) {
+        return endValidation;
+    }
+    return { valid: true };
+}
+/**
+ * Check if a date is disabled
+ */
+export function isDateDisabled(date, disabledDates) {
+    if (!disabledDates) {
+        return false;
+    }
+    if (typeof disabledDates === 'function') {
+        return disabledDates(date);
+    }
+    // Array of disabled dates - compare by date string
+    const dateStr = date.toISOString().split('T')[0];
+    return disabledDates.some(d => d.toISOString().split('T')[0] === dateStr);
+}
+/**
+ * Apply bounds to a date (clamp it)
+ */
+export function applyBounds(date, minDate, maxDate) {
+    let result = date;
+    if (minDate && result < minDate) {
+        result = minDate;
+    }
+    if (maxDate && result > maxDate) {
+        result = maxDate;
+    }
+    return result;
+}
+/**
+ * Parse ISO date string to Date object (deterministic)
+ */
+export function parseISODate(dateStr) {
+    if (!dateStr)
+        return null;
+    const [year, month, day] = dateStr.split('-').map(Number);
+    if (!year || !month || !day)
+        return null;
+    return new Date(year, month - 1, day);
+}
+/**
+ * Format Date to ISO string (YYYY-MM-DD)
+ */
+export function formatISODate(date) {
+    if (!date)
+        return '';
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range.validator.js","sourceRoot":"","sources":["../../../src/core/range.validator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure validation functions for date ranges\n * No dependencies, no side effects - just logic\n * Perfect for SSR, testing, and reusability\n */\n\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n}\n\n/**\n * Validate that end date is not before start date\n */\nexport function validateRangeOrder(start: Date | null, end: Date | null): ValidationResult {\n  if (!start || !end) {\n    return { valid: true }; // Allow incomplete selection\n  }\n\n  if (end < start) {\n    return {\n      valid: false,\n      error: 'End date cannot be before start date'\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate that date is within min/max bounds\n */\nexport function validateDateBounds(\n  date: Date | null,\n  minDate?: Date,\n  maxDate?: Date\n): ValidationResult {\n  if (!date) {\n    return { valid: true };\n  }\n\n  if (minDate && date < minDate) {\n    return {\n      valid: false,\n      error: `Date cannot be before ${minDate.toISOString().split('T')[0]}`\n    };\n  }\n\n  if (maxDate && date > maxDate) {\n    return {\n      valid: false,\n      error: `Date cannot be after ${maxDate.toISOString().split('T')[0]}`\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate that a range is within bounds\n */\nexport function validateRangeBounds(\n  start: Date | null,\n  end: Date | null,\n  minDate?: Date,\n  maxDate?: Date\n): ValidationResult {\n  const startValidation = validateDateBounds(start, minDate, maxDate);\n  if (!startValidation.valid) {\n    return startValidation;\n  }\n\n  const endValidation = validateDateBounds(end, minDate, maxDate);\n  if (!endValidation.valid) {\n    return endValidation;\n  }\n\n  return { valid: true };\n}\n\n/**\n * Check if a date is disabled\n */\nexport function isDateDisabled(\n  date: Date,\n  disabledDates?: Date[] | ((date: Date) => boolean)\n): boolean {\n  if (!disabledDates) {\n    return false;\n  }\n\n  if (typeof disabledDates === 'function') {\n    return disabledDates(date);\n  }\n\n  // Array of disabled dates - compare by date string\n  const dateStr = date.toISOString().split('T')[0];\n  return disabledDates.some(\n    d => d.toISOString().split('T')[0] === dateStr\n  );\n}\n\n/**\n * Apply bounds to a date (clamp it)\n */\nexport function applyBounds(date: Date, minDate?: Date, maxDate?: Date): Date {\n  let result = date;\n\n  if (minDate && result < minDate) {\n    result = minDate;\n  }\n\n  if (maxDate && result > maxDate) {\n    result = maxDate;\n  }\n\n  return result;\n}\n\n/**\n * Parse ISO date string to Date object (deterministic)\n */\nexport function parseISODate(dateStr: string): Date | null {\n  if (!dateStr) return null;\n\n  const [year, month, day] = dateStr.split('-').map(Number);\n  if (!year || !month || !day) return null;\n\n  return new Date(year, month - 1, day);\n}\n\n/**\n * Format Date to ISO string (YYYY-MM-DD)\n */\nexport function formatISODate(date: Date | null): string {\n  if (!date) return '';\n\n  const year = date.getFullYear();\n  const month = String(date.getMonth() + 1).padStart(2, '0');\n  const day = String(date.getDate()).padStart(2, '0');\n\n  return `${year}-${month}-${day}`;\n}\n"]}