@oneluiz/dual-datepicker 3.4.0 → 3.5.1

package/core/native-date-adapter.d.ts

@@ -0,0 +1,152 @@
+import { DateAdapter } from './date-adapter';
+import * as i0 from "@angular/core";
+export declare class NativeDateAdapter implements DateAdapter {
+    /**
+     * Normalize date to start of day (00:00:00.000) in local timezone
+     *
+     * This is the foundation of timezone-safe operations.
+     * All other methods use normalized dates for comparisons.
+     */
+    normalize(date: Date): Date;
+    /**
+     * Check if two dates are the same calendar day
+     *
+     * Implementation: Compare YYYY-MM-DD components directly
+     * Avoids timezone issues from valueOf() comparisons
+     */
+    isSameDay(a: Date, b: Date): boolean;
+    /**
+     * Check if date A is before date B (calendar day level)
+     *
+     * Implementation: Compare normalized dates using valueOf()
+     */
+    isBeforeDay(a: Date, b: Date): boolean;
+    /**
+     * Check if date A is after date B (calendar day level)
+     *
+     * Implementation: Compare normalized dates using valueOf()
+     */
+    isAfterDay(a: Date, b: Date): boolean;
+    /**
+     * Add days to a date
+     *
+     * Implementation: Use setDate() which handles month rollover automatically
+     *
+     * Example:
+     * Jan 31 + 3 days → Feb 3 ✅
+     * Feb 28 + 1 day → Mar 1 ✅ (non-leap year)
+     */
+    addDays(date: Date, days: number): Date;
+    /**
+     * Add months to a date
+     *
+     * CRITICAL: Handles month overflow correctly
+     *
+     * Algorithm:
+     * 1. Add months using setMonth()
+     * 2. If day-of-month changed (overflow), set to last day of target month
+     *
+     * Examples:
+     * - Jan 31 + 1 month → Feb 28 (or Feb 29 in leap year) ✅
+     * - Jan 31 + 2 months → Mar 31 ✅
+     * - Mar 31 + 1 month → Apr 30 ✅
+     * - Dec 31 + 1 month → Jan 31 (next year) ✅
+     */
+    addMonths(date: Date, months: number): Date;
+    /**
+     * Get start of day (00:00:00.000)
+     *
+     * Alias for normalize() with explicit intent
+     */
+    startOfDay(date: Date): Date;
+    /**
+     * Get end of day (23:59:59.999)
+     *
+     * Useful for inclusive range queries
+     */
+    endOfDay(date: Date): Date;
+    /**
+     * Get first day of month (00:00:00.000)
+     */
+    startOfMonth(date: Date): Date;
+    /**
+     * Get last day of month (23:59:59.999)
+     *
+     * Algorithm: Go to 1st of next month, subtract 1 day
+     */
+    endOfMonth(date: Date): Date;
+    /**
+     * Get year (4-digit)
+     */
+    getYear(date: Date): number;
+    /**
+     * Get month (0-11)
+     */
+    getMonth(date: Date): number;
+    /**
+     * Get day of month (1-31)
+     */
+    getDate(date: Date): number;
+    /**
+     * Get day of week (0-6, Sunday=0)
+     */
+    getDay(date: Date): number;
+    /**
+     * Convert Date to ISO date string (YYYY-MM-DD)
+     *
+     * CRITICAL: DO NOT use toISOString() - it converts to UTC!
+     *
+     * Manual construction ensures local timezone is preserved:
+     *
+     * Example problem with toISOString():
+     * ```
+     * // Local timezone: GMT-6 (CST)
+     * const date = new Date('2026-02-21T23:00:00'); // 11 PM Feb 21 local
+     *
+     * // WRONG ❌
+     * date.toISOString().split('T')[0]
+     * // Returns "2026-02-22" (converted to UTC = Feb 22 05:00 AM)
+     *
+     * // CORRECT ✅
+     * toISODate(date)
+     * // Returns "2026-02-21" (local date preserved)
+     * ```
+     *
+     * Implementation: Build YYYY-MM-DD manually from local date components
+     */
+    toISODate(date: Date): string;
+    /**
+     * Parse ISO date string (YYYY-MM-DD) to Date
+     *
+     * CRITICAL: DO NOT use new Date(isoString) - may parse as UTC!
+     *
+     * Example problem with Date constructor:
+     * ```
+     * // Local timezone: GMT-6 (CST)
+     *
+     * // WRONG ❌
+     * new Date('2026-02-21')
+     * // Parsed as UTC: 2026-02-21T00:00:00Z
+     * // In local timezone: Feb 20, 2026 6:00 PM (previous day!)
+     *
+     * // CORRECT ✅
+     * parseISODate('2026-02-21')
+     * // Returns: 2026-02-21T00:00:00 local time
+     * ```
+     *
+     * Implementation: Parse components and construct Date in local timezone
+     */
+    parseISODate(isoDate: string): Date | null;
+    /**
+     * Get week start day for locale
+     *
+     * Default: Sunday (0) for most locales
+     * Monday (1) for Europe, ISO 8601
+     *
+     * Implementation: Simple locale detection
+     * For advanced needs, use Intl.Locale or external library
+     */
+    getWeekStart(locale?: string): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NativeDateAdapter>;
+}

package/core/preset.engine.d.ts

@@ -0,0 +1,88 @@
+import * as i0 from "@angular/core";
+export interface RangePreset {
+    /**
+     * Resolve preset to actual date range
+     * @param now - Current date for deterministic calculation
+     */
+    resolve(now: Date): {
+        start: Date;
+        end: Date;
+    };
+}
+export interface PresetRange {
+    start: string;
+    end: string;
+}
+/**
+ * Registry of built-in presets
+ * Can be extended by consumers
+ *
+ * SSR-Safe Architecture:
+ * - Injects DateClock via DI
+ * - All presets use clock.now() instead of new Date()
+ * - Deterministic: same clock.now() → same preset
+ * - Override DATE_CLOCK token in SSR to ensure consistency
+ *
+ * Timezone-Safe Architecture:
+ * - Injects DateAdapter via DI
+ * - All date operations use adapter methods
+ * - Prevents timezone bugs in cross-timezone scenarios
+ * - Override DATE_ADAPTER for Luxon/DayJS/custom implementations
+ */
+export declare class PresetEngine {
+    private presets;
+    private clock;
+    private adapter;
+    constructor();
+    /**
+     * Register a custom preset
+     */
+    register(key: string, preset: RangePreset): void;
+    /**
+     * Resolve a preset to date range
+     *
+     * SSR Note: Uses injected DateClock for deterministic resolution
+     * Timezone Note: Uses injected DateAdapter for consistent date operations
+     *
+     * Override tokens in SSR scenarios:
+     * - DATE_CLOCK: Control current time
+     * - DATE_ADAPTER: Control date operations (e.g., Luxon for timezone support)
+     *
+     * @param key - Preset key (e.g., 'TODAY', 'LAST_7_DAYS')
+     * @param now - Optional override for current date (defaults to clock.now())
+     */
+    resolve(key: string, now?: Date): PresetRange | null;
+    /**
+     * Get all available preset keys
+     */
+    getPresetKeys(): string[];
+    /**
+     * Register all built-in presets
+     *
+     * All presets now use DateAdapter for timezone-safe operations
+     */
+    private registerBuiltInPresets;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetEngine, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PresetEngine>;
+}
+/**
+ * Create a custom preset from a function
+ */
+export declare function createPreset(resolver: (now: Date) => {
+    start: Date;
+    end: Date;
+}): RangePreset;
+/**
+ * @deprecated Use dependency injection instead:
+ * ```typescript
+ * private engine = inject(PresetEngine);
+ * ```
+ *
+ * Singleton preset engine instance for backward compatibility
+ *
+ * WARNING: This singleton uses SystemClock directly and is NOT SSR-safe.
+ * For SSR applications, inject PresetEngine and override DATE_CLOCK token.
+ *
+ * This export will be removed in v4.0.0
+ */
+export declare const presetEngine: PresetEngine;

package/core/range.validator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Pure validation functions for date ranges
+ * No dependencies, no side effects - just logic
+ * Perfect for SSR, testing, and reusability
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Validate that end date is not before start date
+ */
+export declare function validateRangeOrder(start: Date | null, end: Date | null): ValidationResult;
+/**
+ * Validate that date is within min/max bounds
+ */
+export declare function validateDateBounds(date: Date | null, minDate?: Date, maxDate?: Date): ValidationResult;
+/**
+ * Validate that a range is within bounds
+ */
+export declare function validateRangeBounds(start: Date | null, end: Date | null, minDate?: Date, maxDate?: Date): ValidationResult;
+/**
+ * Check if a date is disabled
+ */
+export declare function isDateDisabled(date: Date, disabledDates?: Date[] | ((date: Date) => boolean)): boolean;
+/**
+ * Apply bounds to a date (clamp it)
+ */
+export declare function applyBounds(date: Date, minDate?: Date, maxDate?: Date): Date;
+/**
+ * Parse ISO date string to Date object (deterministic)
+ */
+export declare function parseISODate(dateStr: string): Date | null;
+/**
+ * Format Date to ISO string (YYYY-MM-DD)
+ */
+export declare function formatISODate(date: Date | null): string;

package/core/system-clock.d.ts

@@ -0,0 +1,13 @@
+import { DateClock } from './date-clock';
+import * as i0 from "@angular/core";
+export declare class SystemClock implements DateClock {
+    /**
+     * Returns current system time
+     *
+     * This is the standard behavior for client-side applications.
+     * For SSR, override DATE_CLOCK token with a fixed Date.
+     */
+    now(): Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemClock, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemClock>;
+}

package/dual-datepicker.component.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter, OnInit, OnChanges, SimpleChanges, ElementRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
+import { DualDateRangeStore } from './core/dual-date-range.store';
 import * as i0 from "@angular/core";
 export interface DateRange {
     startDate: string;
@@ -30,8 +31,10 @@ export type ThemeType = 'default' | 'bootstrap' | 'bulma' | 'foundation' | 'tail
 export declare class DualDatepickerComponent implements OnInit, OnChanges, ControlValueAccessor {
     private elementRef;
     placeholder: string;
-    startDate: string;
-    endDate: string;
+    set startDate(value: string);
+    get startDate(): string;
+    set endDate(value: string);
+    get endDate(): string;
     showPresets: boolean;
     showClearButton: boolean;
     multiRange: boolean;
@@ -61,24 +64,22 @@ export declare class DualDatepickerComponent implements OnInit, OnChanges, Contr
     multiDateRangeChange: EventEmitter<MultiDateRange>;
     multiDateRangeSelected: EventEmitter<MultiDateRange>;
     private dateAdapter;
+    protected readonly rangeStore: DualDateRangeStore;
     showDatePicker: import("@angular/core").WritableSignal<boolean>;
-    dateRangeText: import("@angular/core").WritableSignal<string>;
-    selectingStartDate: import("@angular/core").WritableSignal<boolean>;
     currentMonth: import("@angular/core").WritableSignal<any>;
     previousMonth: import("@angular/core").WritableSignal<any>;
     currentMonthDays: import("@angular/core").WritableSignal<any[]>;
     previousMonthDays: import("@angular/core").WritableSignal<any[]>;
     isDisabled: import("@angular/core").WritableSignal<boolean>;
-    pendingStartDate: string;
-    pendingEndDate: string;
-    hasPendingChanges: import("@angular/core").WritableSignal<boolean>;
-    startHour: number;
-    startMinute: number;
-    endHour: number;
-    endMinute: number;
     showStartTimePicker: import("@angular/core").WritableSignal<boolean>;
     showEndTimePicker: import("@angular/core").WritableSignal<boolean>;
     hoverDate: import("@angular/core").WritableSignal<string>;
+    get startHour(): number;
+    get startMinute(): number;
+    get endHour(): number;
+    get endMinute(): number;
+    private setStartHourMinute;
+    private setEndHourMinute;
     selectedRanges: import("@angular/core").WritableSignal<DateRange[]>;
     currentRangeIndex: import("@angular/core").WritableSignal<number>;
     focusedDay: import("@angular/core").WritableSignal<{
@@ -88,6 +89,11 @@ export declare class DualDatepickerComponent implements OnInit, OnChanges, Contr
     currentMonthName: import("@angular/core").Signal<string>;
     previousMonthName: import("@angular/core").Signal<string>;
     weekDayNames: import("@angular/core").Signal<string[]>;
+    dateRangeText: import("@angular/core").Signal<string>;
+    selectingStartDate: import("@angular/core").Signal<boolean>;
+    hasPendingChanges: import("@angular/core").Signal<boolean>;
+    get pendingStartDate(): string;
+    get pendingEndDate(): string;
     private readonly defaultMonthNames;
     private readonly defaultMonthNamesShort;
     private readonly defaultDayNames;

package/esm2022/core/date-adapter.mjs

@@ -0,0 +1,77 @@
+/**
+ * Date Adapter Abstraction for Timezone-Safe Date Operations
+ *
+ * Problem:
+ * Using Date natively in calendar/range logic causes enterprise bugs:
+ * - Date ranges shift by 1 day due to timezone/DST
+ * - Server (UTC) vs Client (local timezone) discrepancies
+ * - Inconsistent reporting in BI/ERP/invoicing/hotel systems
+ *
+ * Solution:
+ * All date calculations go through an adapter layer.
+ * This allows:
+ * - Timezone-safe operations by default (NativeDateAdapter normalizes to day boundaries)
+ * - Optional integration with Luxon/DayJS/date-fns for advanced timezone handling
+ * - Consistent behavior across SSR and client
+ * - Migration path to timezone-aware libraries without breaking changes
+ *
+ * Architecture:
+ * ```
+ * DualDateRangeStore
+ *     ↓ uses
+ * DateAdapter ← Inject via DATE_ADAPTER token
+ *     ↓ implements
+ * NativeDateAdapter (default, zero deps)
+ * LuxonDateAdapter (optional, full timezone support)
+ * DayJSDateAdapter (optional, lightweight)
+ * ```
+ *
+ * Usage:
+ * ```typescript
+ * // Default (NativeDateAdapter)
+ * bootstrapApplication(AppComponent);
+ *
+ * // Advanced (Luxon with timezone)
+ * import { LuxonDateAdapter } from '@oneluiz/dual-datepicker/luxon';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     { provide: DATE_ADAPTER, useClass: LuxonDateAdapter }
+ *   ]
+ * });
+ * ```
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for DateAdapter
+ *
+ * Default: NativeDateAdapter (zero dependencies)
+ *
+ * Override for advanced timezone handling:
+ *
+ * ```typescript
+ * // Luxon with timezone
+ * import { LuxonDateAdapter } from '@oneluiz/dual-datepicker/luxon';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     {
+ *       provide: DATE_ADAPTER,
+ *       useClass: LuxonDateAdapter
+ *     }
+ *   ]
+ * });
+ * ```
+ *
+ * Custom implementation:
+ *
+ * ```typescript
+ * class CustomDateAdapter implements DateAdapter {
+ *   // Your implementation for backend-specific date handling
+ * }
+ *
+ * provide(DATE_ADAPTER, { useClass: CustomDateAdapter });
+ * ```
+ */
+export const DATE_ADAPTER = new InjectionToken('DATE_ADAPTER');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-adapter.js","sourceRoot":"","sources":["../../../src/core/date-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAiP/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAAc,cAAc,CAAC,CAAC","sourcesContent":["/**\n * Date Adapter Abstraction for Timezone-Safe Date Operations\n * \n * Problem:\n * Using Date natively in calendar/range logic causes enterprise bugs:\n * - Date ranges shift by 1 day due to timezone/DST\n * - Server (UTC) vs Client (local timezone) discrepancies\n * - Inconsistent reporting in BI/ERP/invoicing/hotel systems\n * \n * Solution:\n * All date calculations go through an adapter layer.\n * This allows:\n * - Timezone-safe operations by default (NativeDateAdapter normalizes to day boundaries)\n * - Optional integration with Luxon/DayJS/date-fns for advanced timezone handling\n * - Consistent behavior across SSR and client\n * - Migration path to timezone-aware libraries without breaking changes\n * \n * Architecture:\n * ```\n * DualDateRangeStore\n *     ↓ uses\n * DateAdapter ← Inject via DATE_ADAPTER token\n *     ↓ implements\n * NativeDateAdapter (default, zero deps)\n * LuxonDateAdapter (optional, full timezone support)\n * DayJSDateAdapter (optional, lightweight)\n * ```\n * \n * Usage:\n * ```typescript\n * // Default (NativeDateAdapter)\n * bootstrapApplication(AppComponent);\n * \n * // Advanced (Luxon with timezone)\n * import { LuxonDateAdapter } from '@oneluiz/dual-datepicker/luxon';\n * \n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     { provide: DATE_ADAPTER, useClass: LuxonDateAdapter }\n *   ]\n * });\n * ```\n */\n\nimport { InjectionToken } from '@angular/core';\n\n/**\n * Date adapter interface for all calendar/range operations\n * \n * All methods operate on \"calendar day\" level, ignoring time components.\n * Implementations must ensure timezone-safe behavior.\n * \n * Implementations:\n * - NativeDateAdapter: Default, zero dependencies, uses Date with normalization\n * - LuxonDateAdapter: Optional, full timezone support with Luxon\n * - DayJSDateAdapter: Optional, lightweight timezone support\n * - Custom: Implement for your specific backend/timezone requirements\n */\nexport interface DateAdapter {\n  /**\n   * Normalize date to start of day (00:00:00.000)\n   * \n   * Critical for timezone-safe comparisons.\n   * \n   * Example:\n   * ```typescript\n   * const date = new Date('2026-02-21T15:30:00');\n   * const normalized = adapter.normalize(date);\n   * // → 2026-02-21T00:00:00.000 (in local timezone)\n   * ```\n   * \n   * @param date - Date to normalize\n   * @returns Date with time set to 00:00:00.000\n   */\n  normalize(date: Date): Date;\n\n  /**\n   * Check if two dates represent the same calendar day\n   * \n   * Ignores time component. Timezone-safe.\n   * \n   * Example:\n   * ```typescript\n   * const a = new Date('2026-02-21T23:59:59');\n   * const b = new Date('2026-02-21T00:00:01');\n   * adapter.isSameDay(a, b); // → true\n   * ```\n   */\n  isSameDay(a: Date, b: Date): boolean;\n\n  /**\n   * Check if date A is before date B (calendar day level)\n   * \n   * Example:\n   * ```typescript\n   * adapter.isBeforeDay(new Date('2026-02-20'), new Date('2026-02-21')); // → true\n   * adapter.isBeforeDay(new Date('2026-02-21'), new Date('2026-02-21')); // → false\n   * ```\n   */\n  isBeforeDay(a: Date, b: Date): boolean;\n\n  /**\n   * Check if date A is after date B (calendar day level)\n   * \n   * Example:\n   * ```typescript\n   * adapter.isAfterDay(new Date('2026-02-22'), new Date('2026-02-21')); // → true\n   * adapter.isAfterDay(new Date('2026-02-21'), new Date('2026-02-21')); // → false\n   * ```\n   */\n  isAfterDay(a: Date, b: Date): boolean;\n\n  /**\n   * Add days to a date\n   * \n   * Must handle DST transitions correctly.\n   * \n   * Example:\n   * ```typescript\n   * const date = new Date('2026-02-21');\n   * const future = adapter.addDays(date, 7);\n   * // → 2026-02-28\n   * ```\n   */\n  addDays(date: Date, days: number): Date;\n\n  /**\n   * Add months to a date\n   * \n   * Must handle month overflow (e.g., Jan 31 + 1 month → Feb 28).\n   * \n   * Example:\n   * ```typescript\n   * const date = new Date('2026-01-31');\n   * const next = adapter.addMonths(date, 1);\n   * // → 2026-02-28 (not March 3rd)\n   * ```\n   */\n  addMonths(date: Date, months: number): Date;\n\n  /**\n   * Get start of day (00:00:00.000)\n   * \n   * Similar to normalize() but explicit intent.\n   */\n  startOfDay(date: Date): Date;\n\n  /**\n   * Get end of day (23:59:59.999)\n   * \n   * Useful for range queries that need to include entire day.\n   * \n   * Example:\n   * ```typescript\n   * const date = new Date('2026-02-21');\n   * const end = adapter.endOfDay(date);\n   * // → 2026-02-21T23:59:59.999\n   * ```\n   */\n  endOfDay(date: Date): Date;\n\n  /**\n   * Get first day of month (00:00:00.000)\n   * \n   * Example:\n   * ```typescript\n   * const date = new Date('2026-02-21');\n   * const start = adapter.startOfMonth(date);\n   * // → 2026-02-01T00:00:00.000\n   * ```\n   */\n  startOfMonth(date: Date): Date;\n\n  /**\n   * Get last day of month (23:59:59.999)\n   * \n   * Example:\n   * ```typescript\n   * const date = new Date('2026-02-21');\n   * const end = adapter.endOfMonth(date);\n   * // → 2026-02-28T23:59:59.999\n   * ```\n   */\n  endOfMonth(date: Date): Date;\n\n  /**\n   * Get year (4-digit)\n   * \n   * Example:\n   * ```typescript\n   * adapter.getYear(new Date('2026-02-21')); // → 2026\n   * ```\n   */\n  getYear(date: Date): number;\n\n  /**\n   * Get month (0-11, where 0 = January)\n   * \n   * Example:\n   * ```typescript\n   * adapter.getMonth(new Date('2026-02-21')); // → 1 (February)\n   * ```\n   */\n  getMonth(date: Date): number;\n\n  /**\n   * Get day of month (1-31)\n   * \n   * Example:\n   * ```typescript\n   * adapter.getDate(new Date('2026-02-21')); // → 21\n   * ```\n   */\n  getDate(date: Date): number;\n\n  /**\n   * Get day of week (0-6, where 0 = Sunday)\n   * \n   * Example:\n   * ```typescript\n   * adapter.getDay(new Date('2026-02-21')); // → 6 (Saturday)\n   * ```\n   */\n  getDay(date: Date): number;\n\n  /**\n   * Convert Date to ISO date string (YYYY-MM-DD)\n   * \n   * CRITICAL: Must be timezone-safe!\n   * DO NOT use date.toISOString() as it converts to UTC.\n   * \n   * Example:\n   * ```typescript\n   * // Local timezone GMT-6 (CST)\n   * const date = new Date('2026-02-21T23:00:00'); // 11 PM CST\n   * \n   * // ❌ WRONG: date.toISOString().split('T')[0]\n   * // Returns \"2026-02-22\" (shifted to UTC!)\n   * \n   * // ✅ CORRECT: adapter.toISODate(date)\n   * // Returns \"2026-02-21\" (local date preserved)\n   * ```\n   * \n   * @param date - Date to format (or null)\n   * @returns ISO date string in YYYY-MM-DD format (local timezone), empty string if null\n   */\n  toISODate(date: Date | null): string;\n\n  /**\n   * Parse ISO date string (YYYY-MM-DD) to Date\n   * \n   * CRITICAL: Must be timezone-safe!\n   * DO NOT use new Date(isoString) as it may parse as UTC.\n   * \n   * Example:\n   * ```typescript\n   * // ❌ WRONG: new Date('2026-02-21')\n   * // May parse as UTC midnight, which is previous day in some timezones\n   * \n   * // ✅ CORRECT: adapter.parseISODate('2026-02-21')\n   * // Returns Date representing 2026-02-21 00:00:00 in local timezone\n   * ```\n   * \n   * @param isoDate - ISO date string (YYYY-MM-DD) or null\n   * @returns Date object or null if invalid\n   */\n  parseISODate(isoDate: string | null): Date | null;\n\n  /**\n   * Get week start day for locale\n   * \n   * 0 = Sunday, 1 = Monday, etc.\n   * \n   * Example:\n   * ```typescript\n   * adapter.getWeekStart('en-US'); // → 0 (Sunday)\n   * adapter.getWeekStart('en-GB'); // → 1 (Monday)\n   * ```\n   * \n   * @param locale - Locale string (e.g., 'en-US', 'es-ES')\n   * @returns Day number (0-6)\n   */\n  getWeekStart(locale?: string): 0 | 1 | 2 | 3 | 4 | 5 | 6;\n}\n\n/**\n * Injection token for DateAdapter\n * \n * Default: NativeDateAdapter (zero dependencies)\n * \n * Override for advanced timezone handling:\n * \n * ```typescript\n * // Luxon with timezone\n * import { LuxonDateAdapter } from '@oneluiz/dual-datepicker/luxon';\n * \n * bootstrapApplication(AppComponent, {\n *   providers: [\n *     {\n *       provide: DATE_ADAPTER,\n *       useClass: LuxonDateAdapter\n *     }\n *   ]\n * });\n * ```\n * \n * Custom implementation:\n * \n * ```typescript\n * class CustomDateAdapter implements DateAdapter {\n *   // Your implementation for backend-specific date handling\n * }\n * \n * provide(DATE_ADAPTER, { useClass: CustomDateAdapter });\n * ```\n */\nexport const DATE_ADAPTER = new InjectionToken<DateAdapter>('DATE_ADAPTER');\n"]}

package/esm2022/core/date-clock.mjs

@@ -0,0 +1,65 @@
+/**
+ * Date Clock Abstraction for SSR-Safe Date Resolution
+ *
+ * Problem:
+ * Presets like "Last 7 Days" or "This Month" use new Date() which causes:
+ * - SSR hydration mismatch
+ * - Server renders "2026-02-14", client renders "2026-02-15"
+ * - Different filters in dashboards
+ * - Different queries in ERP/BI
+ * - Cache inconsistency
+ *
+ * Solution:
+ * Inject a DateClock to control time deterministically:
+ *
+ * Server (SSR):
+ * provide(DATE_CLOCK, {
+ *   useValue: { now: () => new Date('2026-02-21T00:00:00Z') }
+ * })
+ *
+ * Client (Browser):
+ * Uses SystemClock by default (new Date())
+ *
+ * Testing:
+ * provide(DATE_CLOCK, {
+ *   useValue: { now: () => new Date('2026-01-15T10:30:00Z') }
+ * })
+ *
+ * Architecture:
+ * - PresetEngine receives DateClock via DI
+ * - All preset calculations use clock.now() instead of new Date()
+ * - Deterministic: Same clock.now() → Same preset result
+ * - SSR-compatible: Server and client resolve identical ranges
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for DateClock
+ *
+ * Usage:
+ * ```typescript
+ * // Default (uses SystemClock)
+ * bootstrapApplication(AppComponent);
+ *
+ * // SSR Override
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     {
+ *       provide: DATE_CLOCK,
+ *       useValue: { now: () => new Date('2026-02-21T00:00:00Z') }
+ *     }
+ *   ]
+ * });
+ *
+ * // Testing Override
+ * TestBed.configureTestingModule({
+ *   providers: [
+ *     {
+ *       provide: DATE_CLOCK,
+ *       useValue: { now: () => new Date('2026-01-15T12:00:00Z') }
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+export const DATE_CLOCK = new InjectionToken('DATE_CLOCK');
+//# sourceMappingURL=data:application/json;base64,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