@oneluiz/dual-datepicker 3.3.0 → 3.5.0

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=

package/esm2022/core/preset.engine.mjs

@@ -0,0 +1,209 @@
+/**
+ * Headless Preset Engine
+ * Pure functions that resolve date ranges WITHOUT render dependency
+ * Perfect for SSR, global state, dashboard filters
+ */
+import { formatISODate } from './range.validator';
+/**
+ * Registry of built-in presets
+ * Can be extended by consumers
+ */
+export class PresetEngine {
+    presets = new Map();
+    constructor() {
+        this.registerBuiltInPresets();
+    }
+    /**
+     * Register a custom preset
+     */
+    register(key, preset) {
+        this.presets.set(key, preset);
+    }
+    /**
+     * Resolve a preset to date range
+     */
+    resolve(key, now = new Date()) {
+        const preset = this.presets.get(key);
+        if (!preset)
+            return null;
+        const { start, end } = preset.resolve(now);
+        return {
+            start: formatISODate(start),
+            end: formatISODate(end)
+        };
+    }
+    /**
+     * Get all available preset keys
+     */
+    getPresetKeys() {
+        return Array.from(this.presets.keys());
+    }
+    /**
+     * Register all built-in presets
+     */
+    registerBuiltInPresets() {
+        // Today
+        this.register('TODAY', {
+            resolve: (now) => ({ start: now, end: now })
+        });
+        // Yesterday
+        this.register('YESTERDAY', {
+            resolve: (now) => {
+                const date = new Date(now);
+                date.setDate(date.getDate() - 1);
+                return { start: date, end: date };
+            }
+        });
+        // Last N Days
+        this.register('LAST_7_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 6);
+                return { start, end };
+            }
+        });
+        this.register('LAST_14_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 13);
+                return { start, end };
+            }
+        });
+        this.register('LAST_30_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 29);
+                return { start, end };
+            }
+        });
+        this.register('LAST_60_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 59);
+                return { start, end };
+            }
+        });
+        this.register('LAST_90_DAYS', {
+            resolve: (now) => {
+                const end = new Date(now);
+                const start = new Date(now);
+                start.setDate(start.getDate() - 89);
+                return { start, end };
+            }
+        });
+        // This Week (Monday to Sunday)
+        this.register('THIS_WEEK', {
+            resolve: (now) => {
+                const dayOfWeek = now.getDay();
+                const start = new Date(now);
+                const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+                start.setDate(start.getDate() - daysToMonday);
+                const end = new Date(start);
+                end.setDate(end.getDate() + 6);
+                return { start, end };
+            }
+        });
+        // Last Week
+        this.register('LAST_WEEK', {
+            resolve: (now) => {
+                const dayOfWeek = now.getDay();
+                const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+                const lastMonday = new Date(now);
+                lastMonday.setDate(lastMonday.getDate() - daysToMonday - 7);
+                const lastSunday = new Date(lastMonday);
+                lastSunday.setDate(lastSunday.getDate() + 6);
+                return { start: lastMonday, end: lastSunday };
+            }
+        });
+        // This Month
+        this.register('THIS_MONTH', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), now.getMonth(), 1);
+                const end = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+                return { start, end };
+            }
+        });
+        // Last Month
+        this.register('LAST_MONTH', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+                const end = new Date(now.getFullYear(), now.getMonth(), 0);
+                return { start, end };
+            }
+        });
+        // Month to Date
+        this.register('MONTH_TO_DATE', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), now.getMonth(), 1);
+                return { start, end: now };
+            }
+        });
+        // This Quarter
+        this.register('THIS_QUARTER', {
+            resolve: (now) => {
+                const currentMonth = now.getMonth();
+                const quarterStartMonth = Math.floor(currentMonth / 3) * 3;
+                const start = new Date(now.getFullYear(), quarterStartMonth, 1);
+                const end = new Date(now.getFullYear(), quarterStartMonth + 3, 0);
+                return { start, end };
+            }
+        });
+        // Last Quarter
+        this.register('LAST_QUARTER', {
+            resolve: (now) => {
+                const currentMonth = now.getMonth();
+                const lastQuarterStartMonth = Math.floor(currentMonth / 3) * 3 - 3;
+                const start = new Date(now.getFullYear(), lastQuarterStartMonth, 1);
+                const end = new Date(now.getFullYear(), lastQuarterStartMonth + 3, 0);
+                return { start, end };
+            }
+        });
+        // Quarter to Date
+        this.register('QUARTER_TO_DATE', {
+            resolve: (now) => {
+                const currentMonth = now.getMonth();
+                const quarterStartMonth = Math.floor(currentMonth / 3) * 3;
+                const start = new Date(now.getFullYear(), quarterStartMonth, 1);
+                return { start, end: now };
+            }
+        });
+        // This Year
+        this.register('THIS_YEAR', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), 0, 1);
+                const end = new Date(now.getFullYear(), 11, 31);
+                return { start, end };
+            }
+        });
+        // Last Year
+        this.register('LAST_YEAR', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear() - 1, 0, 1);
+                const end = new Date(now.getFullYear() - 1, 11, 31);
+                return { start, end };
+            }
+        });
+        // Year to Date
+        this.register('YEAR_TO_DATE', {
+            resolve: (now) => {
+                const start = new Date(now.getFullYear(), 0, 1);
+                return { start, end: now };
+            }
+        });
+    }
+}
+/**
+ * Create a custom preset from a function
+ */
+export function createPreset(resolver) {
+    return { resolve: resolver };
+}
+/**
+ * Singleton preset engine instance
+ */
+export const presetEngine = new PresetEngine();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset.engine.js","sourceRoot":"","sources":["../../../src/core/preset.engine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Headless Preset Engine\n * Pure functions that resolve date ranges WITHOUT render dependency\n * Perfect for SSR, global state, dashboard filters\n */\n\nimport { formatISODate } from './range.validator';\n\nexport interface RangePreset {\n  /**\n   * Resolve preset to actual date range\n   * @param now - Current date for deterministic calculation\n   */\n  resolve(now: Date): { start: Date; end: Date };\n}\n\nexport interface PresetRange {\n  start: string; // ISO format\n  end: string; // ISO format\n}\n\n/**\n * Registry of built-in presets\n * Can be extended by consumers\n */\nexport class PresetEngine {\n  private presets = new Map<string, RangePreset>();\n\n  constructor() {\n    this.registerBuiltInPresets();\n  }\n\n  /**\n   * Register a custom preset\n   */\n  register(key: string, preset: RangePreset): void {\n    this.presets.set(key, preset);\n  }\n\n  /**\n   * Resolve a preset to date range\n   */\n  resolve(key: string, now: Date = new Date()): PresetRange | null {\n    const preset = this.presets.get(key);\n    if (!preset) return null;\n\n    const { start, end } = preset.resolve(now);\n    return {\n      start: formatISODate(start),\n      end: formatISODate(end)\n    };\n  }\n\n  /**\n   * Get all available preset keys\n   */\n  getPresetKeys(): string[] {\n    return Array.from(this.presets.keys());\n  }\n\n  /**\n   * Register all built-in presets\n   */\n  private registerBuiltInPresets(): void {\n    // Today\n    this.register('TODAY', {\n      resolve: (now) => ({ start: now, end: now })\n    });\n\n    // Yesterday\n    this.register('YESTERDAY', {\n      resolve: (now) => {\n        const date = new Date(now);\n        date.setDate(date.getDate() - 1);\n        return { start: date, end: date };\n      }\n    });\n\n    // Last N Days\n    this.register('LAST_7_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 6);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_14_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 13);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_30_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 29);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_60_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 59);\n        return { start, end };\n      }\n    });\n\n    this.register('LAST_90_DAYS', {\n      resolve: (now) => {\n        const end = new Date(now);\n        const start = new Date(now);\n        start.setDate(start.getDate() - 89);\n        return { start, end };\n      }\n    });\n\n    // This Week (Monday to Sunday)\n    this.register('THIS_WEEK', {\n      resolve: (now) => {\n        const dayOfWeek = now.getDay();\n        const start = new Date(now);\n        const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;\n        start.setDate(start.getDate() - daysToMonday);\n\n        const end = new Date(start);\n        end.setDate(end.getDate() + 6);\n\n        return { start, end };\n      }\n    });\n\n    // Last Week\n    this.register('LAST_WEEK', {\n      resolve: (now) => {\n        const dayOfWeek = now.getDay();\n        const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;\n\n        const lastMonday = new Date(now);\n        lastMonday.setDate(lastMonday.getDate() - daysToMonday - 7);\n\n        const lastSunday = new Date(lastMonday);\n        lastSunday.setDate(lastSunday.getDate() + 6);\n\n        return { start: lastMonday, end: lastSunday };\n      }\n    });\n\n    // This Month\n    this.register('THIS_MONTH', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), now.getMonth(), 1);\n        const end = new Date(now.getFullYear(), now.getMonth() + 1, 0);\n        return { start, end };\n      }\n    });\n\n    // Last Month\n    this.register('LAST_MONTH', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), now.getMonth() - 1, 1);\n        const end = new Date(now.getFullYear(), now.getMonth(), 0);\n        return { start, end };\n      }\n    });\n\n    // Month to Date\n    this.register('MONTH_TO_DATE', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), now.getMonth(), 1);\n        return { start, end: now };\n      }\n    });\n\n    // This Quarter\n    this.register('THIS_QUARTER', {\n      resolve: (now) => {\n        const currentMonth = now.getMonth();\n        const quarterStartMonth = Math.floor(currentMonth / 3) * 3;\n        const start = new Date(now.getFullYear(), quarterStartMonth, 1);\n        const end = new Date(now.getFullYear(), quarterStartMonth + 3, 0);\n        return { start, end };\n      }\n    });\n\n    // Last Quarter\n    this.register('LAST_QUARTER', {\n      resolve: (now) => {\n        const currentMonth = now.getMonth();\n        const lastQuarterStartMonth = Math.floor(currentMonth / 3) * 3 - 3;\n        const start = new Date(now.getFullYear(), lastQuarterStartMonth, 1);\n        const end = new Date(now.getFullYear(), lastQuarterStartMonth + 3, 0);\n        return { start, end };\n      }\n    });\n\n    // Quarter to Date\n    this.register('QUARTER_TO_DATE', {\n      resolve: (now) => {\n        const currentMonth = now.getMonth();\n        const quarterStartMonth = Math.floor(currentMonth / 3) * 3;\n        const start = new Date(now.getFullYear(), quarterStartMonth, 1);\n        return { start, end: now };\n      }\n    });\n\n    // This Year\n    this.register('THIS_YEAR', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), 0, 1);\n        const end = new Date(now.getFullYear(), 11, 31);\n        return { start, end };\n      }\n    });\n\n    // Last Year\n    this.register('LAST_YEAR', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear() - 1, 0, 1);\n        const end = new Date(now.getFullYear() - 1, 11, 31);\n        return { start, end };\n      }\n    });\n\n    // Year to Date\n    this.register('YEAR_TO_DATE', {\n      resolve: (now) => {\n        const start = new Date(now.getFullYear(), 0, 1);\n        return { start, end: now };\n      }\n    });\n  }\n}\n\n/**\n * Create a custom preset from a function\n */\nexport function createPreset(\n  resolver: (now: Date) => { start: Date; end: Date }\n): RangePreset {\n  return { resolve: resolver };\n}\n\n/**\n * Singleton preset engine instance\n */\nexport const presetEngine = new PresetEngine();\n"]}