@oneluiz/dual-datepicker 3.4.0 → 3.5.0

package/README.md

@@ -2,6 +2,8 @@
 
 A lightweight, zero-dependency date range picker for Angular 17+. Built with standalone components, Reactive Forms, and Angular Signals. No Angular Material required.
 
+> **🆕 NEW in v3.5.0**: [**Headless Architecture**](HEADLESS.md) - Use date range state WITHOUT the UI component. Perfect for SSR, services, and global dashboard filters! 🎯
+
 [![npm version](https://img.shields.io/npm/v/@oneluiz/dual-datepicker)](https://www.npmjs.com/package/@oneluiz/dual-datepicker)
 [![npm provenance](https://img.shields.io/badge/provenance-available-brightgreen)](https://www.npmjs.com/package/@oneluiz/dual-datepicker)
 ![license](https://img.shields.io/npm/l/@oneluiz/dual-datepicker)
@@ -17,6 +19,35 @@ npm install @oneluiz/dual-datepicker
 
 ---
 
+## 🌟 What's New
+
+### Headless Architecture (v3.5.0)
+
+Use date range logic **without the UI component**:
+
+```typescript
+// Inject the store anywhere - no UI needed!
+const rangeStore = inject(DualDateRangeStore);
+
+// Apply preset
+rangeStore.applyPreset('THIS_MONTH');
+
+// Use in API calls
+const range = rangeStore.range();
+http.get(`/api/sales?start=${range.start}&end=${range.end}`);
+```
+
+**Perfect for:**
+- 📊 Dashboard filters (control multiple charts)
+- 🏢 SSR applications
+- 🔄 Global state management
+- 🎯 Service-layer filtering
+- 📈 Analytics and BI tools
+
+**[📖 Read the Headless Architecture Guide →](HEADLESS.md)**
+
+---
+
 ## 📋 Table of Contents
 
 - [Features](#-features)
@@ -26,6 +57,7 @@ npm install @oneluiz/dual-datepicker
   - [Basic Usage](#basic-usage)
   - [Reactive Forms](#with-reactive-forms)
   - [Angular Signals](#with-angular-signals)
+  - [Headless Usage](#headless-usage-new) ⭐ NEW
 - [Advanced Features](#-advanced-features)
   - [Multi-Range Selection](#multi-range-support)
   - [Disabled Dates](#disabled-dates)
@@ -169,6 +201,52 @@ dateRange = signal<DateRange | null>(null);
 </ngx-dual-datepicker>
 ```
 
+### Headless Usage (NEW) ⭐
+
+**Use date range state WITHOUT the UI component** - perfect for SSR, services, and global filters!
+
+```typescript
+import { Component, inject } from '@angular/core';
+import { DualDateRangeStore } from '@oneluiz/dual-datepicker';
+import { HttpClient } from '@angular/common/http';
+
+@Component({
+  template: `
+    <div class="dashboard">
+      <button (click)="setPreset('TODAY')">Today</button>
+      <button (click)="setPreset('THIS_MONTH')">This Month</button>
+      <p>{{ rangeText() }}</p>
+    </div>
+  `
+})
+export class DashboardComponent {
+  private rangeStore = inject(DualDateRangeStore);
+  private http = inject(HttpClient);
+  
+  // Expose signals for template
+  rangeText = this.rangeStore.rangeText;
+  
+  setPreset(key: string) {
+    this.rangeStore.applyPreset(key);
+    
+    // Use in API call
+    const range = this.rangeStore.range();
+    this.http.get(`/api/sales`, { 
+      params: { start: range.start, end: range.end } 
+    }).subscribe(data => console.log(data));
+  }
+}
+```
+
+**Benefits:**
+- ✅ No UI component needed
+- ✅ SSR-compatible
+- ✅ Global state management
+- ✅ Perfect for services and guards
+- ✅ Testable and deterministic
+
+**[📖 Full Headless Architecture Guide →](HEADLESS.md)** | **[💻 Code Examples →](HEADLESS_EXAMPLES.ts)**
+
 ---
 
 ## 🎯 Advanced Features
@@ -1998,6 +2076,12 @@ export class ExampleComponent {
 
 Recently shipped:
 
+**v3.4.0:**
+- ✅ **Time Picker** - Select precise datetime ranges with 12h/24h format
+- ✅ **Configurable Minute Steps** - Choose 1, 5, 15, or 30-minute intervals
+- ✅ **Default Times** - Set default start/end times
+- ✅ **Full Theme Support** - Works seamlessly with all built-in themes
+
 **v3.3.0:**
 - ✅ **Theming System** - Pre-built themes for Bootstrap, Bulma, Foundation, Tailwind CSS, and Custom
 - ✅ **CSS Variables Support** - 13 customizable variables for branding
@@ -2025,9 +2109,10 @@ Recently shipped:
 
 Planned features:
 
-- ⬜ **Time Picker** - Select date + time ranges
 - ⬜ **Mobile Optimizations** - Enhanced touch gestures and responsive layout
 - ⬜ **Range Shortcuts** - Quick selection buttons (Today, This Week, etc.)
+- ⬜ **Time Constraints** - Min/max time validation and business hours
+- ⬜ **Multi-range + Time Picker** - Combined support for multiple datetime ranges
 
 ## 📄 License
 

package/core/dual-date-range.store.d.ts

@@ -0,0 +1,104 @@
+import * as i0 from "@angular/core";
+export interface DateRangeState {
+    start: string;
+    end: string;
+    startTime?: string;
+    endTime?: string;
+}
+export interface DateRangeConfig {
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[] | ((date: Date) => boolean);
+    enableTimePicker?: boolean;
+    defaultStartTime?: string;
+    defaultEndTime?: string;
+}
+export declare class DualDateRangeStore {
+    private config;
+    private _startDate;
+    private _endDate;
+    private _leftMonth;
+    private _rightMonth;
+    private _selectingStart;
+    private _startTime;
+    private _endTime;
+    private _pendingStart;
+    private _pendingEnd;
+    private _hasPendingChanges;
+    readonly startDate: import("@angular/core").Signal<Date>;
+    readonly endDate: import("@angular/core").Signal<Date>;
+    readonly leftMonth: import("@angular/core").Signal<Date>;
+    readonly rightMonth: import("@angular/core").Signal<Date>;
+    readonly selectingStart: import("@angular/core").Signal<boolean>;
+    readonly startTime: import("@angular/core").Signal<string>;
+    readonly endTime: import("@angular/core").Signal<string>;
+    readonly hasPendingChanges: import("@angular/core").Signal<boolean>;
+    readonly range: import("@angular/core").Signal<DateRangeState>;
+    readonly isValid: import("@angular/core").Signal<boolean>;
+    readonly rangeText: import("@angular/core").Signal<string>;
+    /**
+     * Configure the store
+     */
+    configure(config: Partial<DateRangeConfig>): void;
+    /**
+     * Set start date (with validation)
+     */
+    setStart(date: Date | string | null): void;
+    /**
+     * Set end date (with validation)
+     */
+    setEnd(date: Date | string | null): void;
+    /**
+     * Set complete range at once
+     */
+    setRange(start: Date | string | null, end: Date | string | null): void;
+    /**
+     * Set pending selection (for requireApply mode)
+     */
+    setPendingStart(date: Date | string | null): void;
+    setPendingEnd(date: Date | string | null): void;
+    /**
+     * Apply pending changes
+     */
+    applyPending(): void;
+    /**
+     * Cancel pending changes
+     */
+    cancelPending(): void;
+    private clearPending;
+    /**
+     * Reset to empty state
+     */
+    reset(): void;
+    /**
+     * Apply a preset by key
+     */
+    applyPreset(presetKey: string, now?: Date): void;
+    /**
+     * Navigate left calendar month
+     */
+    setLeftMonth(date: Date): void;
+    /**
+     * Navigate right calendar month
+     */
+    setRightMonth(date: Date): void;
+    /**
+     * Set time values
+     */
+    setStartTime(time: string): void;
+    setEndTime(time: string): void;
+    /**
+     * Get current state as snapshot
+     */
+    getSnapshot(): DateRangeState;
+    /**
+     * Load state from snapshot
+     */
+    loadSnapshot(snapshot: DateRangeState): void;
+    private parseDate;
+    private getNextMonth;
+    private getPreviousMonth;
+    private formatDateShort;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DualDateRangeStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DualDateRangeStore>;
+}

package/core/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Core headless date range logic
+ * Import from here for clean barrel exports
+ */
+export * from './dual-date-range.store';
+export * from './preset.engine';
+export * from './range.validator';

package/core/preset.engine.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Headless Preset Engine
+ * Pure functions that resolve date ranges WITHOUT render dependency
+ * Perfect for SSR, global state, dashboard filters
+ */
+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
+ */
+export declare class PresetEngine {
+    private presets;
+    constructor();
+    /**
+     * Register a custom preset
+     */
+    register(key: string, preset: RangePreset): void;
+    /**
+     * Resolve a preset to date range
+     */
+    resolve(key: string, now?: Date): PresetRange | null;
+    /**
+     * Get all available preset keys
+     */
+    getPresetKeys(): string[];
+    /**
+     * Register all built-in presets
+     */
+    private registerBuiltInPresets;
+}
+/**
+ * Create a custom preset from a function
+ */
+export declare function createPreset(resolver: (now: Date) => {
+    start: Date;
+    end: Date;
+}): RangePreset;
+/**
+ * Singleton preset engine instance
+ */
+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/esm2022/core/dual-date-range.store.mjs

@@ -0,0 +1,293 @@
+/**
+ * Headless Date Range Store using Angular Signals
+ *
+ * Architecture:
+ * - State lives HERE, not in UI component
+ * - Deterministic: no hidden side effects
+ * - SSR-compatible: no window/document dependencies
+ * - Testable: pure signal-based state
+ * - Reusable: inject anywhere (services, components, guards)
+ *
+ * Usage:
+ * ```typescript
+ * // In component
+ * const rangeStore = inject(DualDateRangeStore);
+ * rangeStore.applyPreset('THIS_MONTH');
+ *
+ * // In service (headless!)
+ * const store = inject(DualDateRangeStore);
+ * const range = store.range();
+ * this.http.get(`/api/sales?start=${range.start}&end=${range.end}`);
+ * ```
+ */
+import { Injectable, signal, computed } from '@angular/core';
+import { validateRangeOrder, validateRangeBounds, isDateDisabled, applyBounds, parseISODate, formatISODate } from './range.validator';
+import { presetEngine } from './preset.engine';
+import * as i0 from "@angular/core";
+export class DualDateRangeStore {
+    // Configuration
+    config = signal({
+        enableTimePicker: false,
+        defaultStartTime: '00:00',
+        defaultEndTime: '23:59'
+    });
+    // Core state - using signals
+    _startDate = signal(null);
+    _endDate = signal(null);
+    _leftMonth = signal(new Date());
+    _rightMonth = signal(this.getNextMonth(new Date()));
+    _selectingStart = signal(true);
+    // Time state
+    _startTime = signal('00:00');
+    _endTime = signal('23:59');
+    // Pending state for requireApply mode
+    _pendingStart = signal(null);
+    _pendingEnd = signal(null);
+    _hasPendingChanges = signal(false);
+    // Public read-only signals
+    startDate = this._startDate.asReadonly();
+    endDate = this._endDate.asReadonly();
+    leftMonth = this._leftMonth.asReadonly();
+    rightMonth = this._rightMonth.asReadonly();
+    selectingStart = this._selectingStart.asReadonly();
+    startTime = this._startTime.asReadonly();
+    endTime = this._endTime.asReadonly();
+    hasPendingChanges = this._hasPendingChanges.asReadonly();
+    // Computed: ISO range for API consumption
+    range = computed(() => {
+        const start = this._startDate();
+        const end = this._endDate();
+        const cfg = this.config();
+        const result = {
+            start: formatISODate(start),
+            end: formatISODate(end)
+        };
+        if (cfg.enableTimePicker) {
+            result.startTime = this._startTime();
+            result.endTime = this._endTime();
+        }
+        return result;
+    });
+    // Computed: validation state
+    isValid = computed(() => {
+        const start = this._startDate();
+        const end = this._endDate();
+        const cfg = this.config();
+        const orderValidation = validateRangeOrder(start, end);
+        if (!orderValidation.valid)
+            return false;
+        const boundsValidation = validateRangeBounds(start, end, cfg.minDate, cfg.maxDate);
+        return boundsValidation.valid;
+    });
+    // Computed: range text for display
+    rangeText = computed(() => {
+        const start = this._startDate();
+        const end = this._endDate();
+        if (!start && !end)
+            return '';
+        if (!start)
+            return `? - ${this.formatDateShort(end)}`;
+        if (!end)
+            return `${this.formatDateShort(start)}`;
+        return `${this.formatDateShort(start)} - ${this.formatDateShort(end)}`;
+    });
+    /**
+     * Configure the store
+     */
+    configure(config) {
+        this.config.update(current => ({ ...current, ...config }));
+    }
+    /**
+     * Set start date (with validation)
+     */
+    setStart(date) {
+        const parsedDate = this.parseDate(date);
+        if (parsedDate) {
+            const cfg = this.config();
+            // Apply bounds
+            const boundedDate = applyBounds(parsedDate, cfg.minDate, cfg.maxDate);
+            // Check if disabled
+            if (isDateDisabled(boundedDate, cfg.disabledDates)) {
+                console.warn('Cannot select disabled date');
+                return;
+            }
+            this._startDate.set(boundedDate);
+            this._selectingStart.set(false);
+            // Auto-adjust end if it becomes invalid
+            const end = this._endDate();
+            if (end && end < boundedDate) {
+                this._endDate.set(null);
+            }
+        }
+        else {
+            this._startDate.set(null);
+        }
+    }
+    /**
+     * Set end date (with validation)
+     */
+    setEnd(date) {
+        const parsedDate = this.parseDate(date);
+        if (parsedDate) {
+            const cfg = this.config();
+            // Apply bounds
+            const boundedDate = applyBounds(parsedDate, cfg.minDate, cfg.maxDate);
+            // Check if disabled
+            if (isDateDisabled(boundedDate, cfg.disabledDates)) {
+                console.warn('Cannot select disabled date');
+                return;
+            }
+            // Validate order
+            const start = this._startDate();
+            if (start && boundedDate < start) {
+                console.warn('End date cannot be before start date');
+                return;
+            }
+            this._endDate.set(boundedDate);
+            this._selectingStart.set(true); // Ready for next selection
+        }
+        else {
+            this._endDate.set(null);
+        }
+    }
+    /**
+     * Set complete range at once
+     */
+    setRange(start, end) {
+        this.setStart(start);
+        this.setEnd(end);
+    }
+    /**
+     * Set pending selection (for requireApply mode)
+     */
+    setPendingStart(date) {
+        const parsedDate = this.parseDate(date);
+        this._pendingStart.set(parsedDate);
+        this._hasPendingChanges.set(true);
+    }
+    setPendingEnd(date) {
+        const parsedDate = this.parseDate(date);
+        this._pendingEnd.set(parsedDate);
+        this._hasPendingChanges.set(true);
+    }
+    /**
+     * Apply pending changes
+     */
+    applyPending() {
+        const pendingStart = this._pendingStart();
+        const pendingEnd = this._pendingEnd();
+        if (pendingStart)
+            this.setStart(pendingStart);
+        if (pendingEnd)
+            this.setEnd(pendingEnd);
+        this.clearPending();
+    }
+    /**
+     * Cancel pending changes
+     */
+    cancelPending() {
+        this.clearPending();
+    }
+    clearPending() {
+        this._pendingStart.set(null);
+        this._pendingEnd.set(null);
+        this._hasPendingChanges.set(false);
+    }
+    /**
+     * Reset to empty state
+     */
+    reset() {
+        this._startDate.set(null);
+        this._endDate.set(null);
+        this._selectingStart.set(true);
+        this.clearPending();
+    }
+    /**
+     * Apply a preset by key
+     */
+    applyPreset(presetKey, now = new Date()) {
+        const range = presetEngine.resolve(presetKey, now);
+        if (range) {
+            this.setRange(range.start, range.end);
+        }
+        else {
+            console.warn(`Preset "${presetKey}" not found`);
+        }
+    }
+    /**
+     * Navigate left calendar month
+     */
+    setLeftMonth(date) {
+        this._leftMonth.set(date);
+        // Ensure right month is always after left
+        const right = this._rightMonth();
+        if (right <= date) {
+            this._rightMonth.set(this.getNextMonth(date));
+        }
+    }
+    /**
+     * Navigate right calendar month
+     */
+    setRightMonth(date) {
+        this._rightMonth.set(date);
+        // Ensure left month is always before right
+        const left = this._leftMonth();
+        if (left >= date) {
+            this._leftMonth.set(this.getPreviousMonth(date));
+        }
+    }
+    /**
+     * Set time values
+     */
+    setStartTime(time) {
+        this._startTime.set(time);
+    }
+    setEndTime(time) {
+        this._endTime.set(time);
+    }
+    /**
+     * Get current state as snapshot
+     */
+    getSnapshot() {
+        return this.range();
+    }
+    /**
+     * Load state from snapshot
+     */
+    loadSnapshot(snapshot) {
+        this.setRange(snapshot.start, snapshot.end);
+        if (snapshot.startTime) {
+            this.setStartTime(snapshot.startTime);
+        }
+        if (snapshot.endTime) {
+            this.setEndTime(snapshot.endTime);
+        }
+    }
+    // Helper methods
+    parseDate(date) {
+        if (!date)
+            return null;
+        if (date instanceof Date)
+            return date;
+        return parseISODate(date);
+    }
+    getNextMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 1);
+    }
+    getPreviousMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() - 1, 1);
+    }
+    formatDateShort(date) {
+        const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+        return `${date.getDate()} ${months[date.getMonth()]}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DualDateRangeStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DualDateRangeStore, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DualDateRangeStore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dual-date-range.store.js","sourceRoot":"","sources":["../../../src/core/dual-date-range.store.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Headless Date Range Store using Angular Signals\n * \n * Architecture:\n * - State lives HERE, not in UI component\n * - Deterministic: no hidden side effects\n * - SSR-compatible: no window/document dependencies\n * - Testable: pure signal-based state\n * - Reusable: inject anywhere (services, components, guards)\n * \n * Usage:\n * ```typescript\n * // In component\n * const rangeStore = inject(DualDateRangeStore);\n * rangeStore.applyPreset('THIS_MONTH');\n * \n * // In service (headless!)\n * const store = inject(DualDateRangeStore);\n * const range = store.range();\n * this.http.get(`/api/sales?start=${range.start}&end=${range.end}`);\n * ```\n */\n\nimport { Injectable, signal, computed, effect, inject } from '@angular/core';\nimport { \n  validateRangeOrder, \n  validateRangeBounds, \n  isDateDisabled,\n  applyBounds,\n  parseISODate,\n  formatISODate\n} from './range.validator';\nimport { presetEngine, PresetRange } from './preset.engine';\n\nexport interface DateRangeState {\n  start: string; // ISO date\n  end: string; // ISO date\n  startTime?: string; // HH:mm\n  endTime?: string; // HH:mm\n}\n\nexport interface DateRangeConfig {\n  minDate?: Date;\n  maxDate?: Date;\n  disabledDates?: Date[] | ((date: Date) => boolean);\n  enableTimePicker?: boolean;\n  defaultStartTime?: string;\n  defaultEndTime?: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DualDateRangeStore {\n  // Configuration\n  private config = signal<DateRangeConfig>({\n    enableTimePicker: false,\n    defaultStartTime: '00:00',\n    defaultEndTime: '23:59'\n  });\n\n  // Core state - using signals\n  private _startDate = signal<Date | null>(null);\n  private _endDate = signal<Date | null>(null);\n  private _leftMonth = signal<Date>(new Date());\n  private _rightMonth = signal<Date>(this.getNextMonth(new Date()));\n  private _selectingStart = signal<boolean>(true);\n\n  // Time state\n  private _startTime = signal<string>('00:00');\n  private _endTime = signal<string>('23:59');\n\n  // Pending state for requireApply mode\n  private _pendingStart = signal<Date | null>(null);\n  private _pendingEnd = signal<Date | null>(null);\n  private _hasPendingChanges = signal<boolean>(false);\n\n  // Public read-only signals\n  readonly startDate = this._startDate.asReadonly();\n  readonly endDate = this._endDate.asReadonly();\n  readonly leftMonth = this._leftMonth.asReadonly();\n  readonly rightMonth = this._rightMonth.asReadonly();\n  readonly selectingStart = this._selectingStart.asReadonly();\n  readonly startTime = this._startTime.asReadonly();\n  readonly endTime = this._endTime.asReadonly();\n  readonly hasPendingChanges = this._hasPendingChanges.asReadonly();\n\n  // Computed: ISO range for API consumption\n  readonly range = computed<DateRangeState>(() => {\n    const start = this._startDate();\n    const end = this._endDate();\n    const cfg = this.config();\n\n    const result: DateRangeState = {\n      start: formatISODate(start),\n      end: formatISODate(end)\n    };\n\n    if (cfg.enableTimePicker) {\n      result.startTime = this._startTime();\n      result.endTime = this._endTime();\n    }\n\n    return result;\n  });\n\n  // Computed: validation state\n  readonly isValid = computed(() => {\n    const start = this._startDate();\n    const end = this._endDate();\n    const cfg = this.config();\n\n    const orderValidation = validateRangeOrder(start, end);\n    if (!orderValidation.valid) return false;\n\n    const boundsValidation = validateRangeBounds(\n      start,\n      end,\n      cfg.minDate,\n      cfg.maxDate\n    );\n    return boundsValidation.valid;\n  });\n\n  // Computed: range text for display\n  readonly rangeText = computed(() => {\n    const start = this._startDate();\n    const end = this._endDate();\n\n    if (!start && !end) return '';\n    if (!start) return `? - ${this.formatDateShort(end!)}`;\n    if (!end) return `${this.formatDateShort(start)}`;\n\n    return `${this.formatDateShort(start)} - ${this.formatDateShort(end)}`;\n  });\n\n  /**\n   * Configure the store\n   */\n  configure(config: Partial<DateRangeConfig>): void {\n    this.config.update(current => ({ ...current, ...config }));\n  }\n\n  /**\n   * Set start date (with validation)\n   */\n  setStart(date: Date | string | null): void {\n    const parsedDate = this.parseDate(date);\n    \n    if (parsedDate) {\n      const cfg = this.config();\n      \n      // Apply bounds\n      const boundedDate = applyBounds(parsedDate, cfg.minDate, cfg.maxDate);\n      \n      // Check if disabled\n      if (isDateDisabled(boundedDate, cfg.disabledDates)) {\n        console.warn('Cannot select disabled date');\n        return;\n      }\n\n      this._startDate.set(boundedDate);\n      this._selectingStart.set(false);\n\n      // Auto-adjust end if it becomes invalid\n      const end = this._endDate();\n      if (end && end < boundedDate) {\n        this._endDate.set(null);\n      }\n    } else {\n      this._startDate.set(null);\n    }\n  }\n\n  /**\n   * Set end date (with validation)\n   */\n  setEnd(date: Date | string | null): void {\n    const parsedDate = this.parseDate(date);\n    \n    if (parsedDate) {\n      const cfg = this.config();\n      \n      // Apply bounds\n      const boundedDate = applyBounds(parsedDate, cfg.minDate, cfg.maxDate);\n      \n      // Check if disabled\n      if (isDateDisabled(boundedDate, cfg.disabledDates)) {\n        console.warn('Cannot select disabled date');\n        return;\n      }\n\n      // Validate order\n      const start = this._startDate();\n      if (start && boundedDate < start) {\n        console.warn('End date cannot be before start date');\n        return;\n      }\n\n      this._endDate.set(boundedDate);\n      this._selectingStart.set(true); // Ready for next selection\n    } else {\n      this._endDate.set(null);\n    }\n  }\n\n  /**\n   * Set complete range at once\n   */\n  setRange(start: Date | string | null, end: Date | string | null): void {\n    this.setStart(start);\n    this.setEnd(end);\n  }\n\n  /**\n   * Set pending selection (for requireApply mode)\n   */\n  setPendingStart(date: Date | string | null): void {\n    const parsedDate = this.parseDate(date);\n    this._pendingStart.set(parsedDate);\n    this._hasPendingChanges.set(true);\n  }\n\n  setPendingEnd(date: Date | string | null): void {\n    const parsedDate = this.parseDate(date);\n    this._pendingEnd.set(parsedDate);\n    this._hasPendingChanges.set(true);\n  }\n\n  /**\n   * Apply pending changes\n   */\n  applyPending(): void {\n    const pendingStart = this._pendingStart();\n    const pendingEnd = this._pendingEnd();\n\n    if (pendingStart) this.setStart(pendingStart);\n    if (pendingEnd) this.setEnd(pendingEnd);\n\n    this.clearPending();\n  }\n\n  /**\n   * Cancel pending changes\n   */\n  cancelPending(): void {\n    this.clearPending();\n  }\n\n  private clearPending(): void {\n    this._pendingStart.set(null);\n    this._pendingEnd.set(null);\n    this._hasPendingChanges.set(false);\n  }\n\n  /**\n   * Reset to empty state\n   */\n  reset(): void {\n    this._startDate.set(null);\n    this._endDate.set(null);\n    this._selectingStart.set(true);\n    this.clearPending();\n  }\n\n  /**\n   * Apply a preset by key\n   */\n  applyPreset(presetKey: string, now: Date = new Date()): void {\n    const range = presetEngine.resolve(presetKey, now);\n    \n    if (range) {\n      this.setRange(range.start, range.end);\n    } else {\n      console.warn(`Preset \"${presetKey}\" not found`);\n    }\n  }\n\n  /**\n   * Navigate left calendar month\n   */\n  setLeftMonth(date: Date): void {\n    this._leftMonth.set(date);\n    \n    // Ensure right month is always after left\n    const right = this._rightMonth();\n    if (right <= date) {\n      this._rightMonth.set(this.getNextMonth(date));\n    }\n  }\n\n  /**\n   * Navigate right calendar month\n   */\n  setRightMonth(date: Date): void {\n    this._rightMonth.set(date);\n    \n    // Ensure left month is always before right\n    const left = this._leftMonth();\n    if (left >= date) {\n      this._leftMonth.set(this.getPreviousMonth(date));\n    }\n  }\n\n  /**\n   * Set time values\n   */\n  setStartTime(time: string): void {\n    this._startTime.set(time);\n  }\n\n  setEndTime(time: string): void {\n    this._endTime.set(time);\n  }\n\n  /**\n   * Get current state as snapshot\n   */\n  getSnapshot(): DateRangeState {\n    return this.range();\n  }\n\n  /**\n   * Load state from snapshot\n   */\n  loadSnapshot(snapshot: DateRangeState): void {\n    this.setRange(snapshot.start, snapshot.end);\n    \n    if (snapshot.startTime) {\n      this.setStartTime(snapshot.startTime);\n    }\n    \n    if (snapshot.endTime) {\n      this.setEndTime(snapshot.endTime);\n    }\n  }\n\n  // Helper methods\n  private parseDate(date: Date | string | null): Date | null {\n    if (!date) return null;\n    if (date instanceof Date) return date;\n    return parseISODate(date);\n  }\n\n  private getNextMonth(date: Date): Date {\n    return new Date(date.getFullYear(), date.getMonth() + 1, 1);\n  }\n\n  private getPreviousMonth(date: Date): Date {\n    return new Date(date.getFullYear(), date.getMonth() - 1, 1);\n  }\n\n  private formatDateShort(date: Date): string {\n    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n    return `${date.getDate()} ${months[date.getMonth()]}`;\n  }\n}\n"]}

package/esm2022/core/index.mjs

@@ -0,0 +1,8 @@
+/**
+ * Core headless date range logic
+ * Import from here for clean barrel exports
+ */
+export * from './dual-date-range.store';
+export * from './preset.engine';
+export * from './range.validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29yZSBoZWFkbGVzcyBkYXRlIHJhbmdlIGxvZ2ljXG4gKiBJbXBvcnQgZnJvbSBoZXJlIGZvciBjbGVhbiBiYXJyZWwgZXhwb3J0c1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZHVhbC1kYXRlLXJhbmdlLnN0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJlc2V0LmVuZ2luZSc7XG5leHBvcnQgKiBmcm9tICcuL3JhbmdlLnZhbGlkYXRvcic7XG4iXX0=