@oneluiz/dual-datepicker 3.5.0 → 3.6.0

package/core/range-preset.plugin.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Range Preset Plugin System
+ *
+ * Version: 3.6.0
+ *
+ * Plugin-based architecture for date range presets following Open/Closed Principle.
+ *
+ * WHY THIS EXISTS:
+ * - Enterprise apps need industry-specific presets (fiscal, hotel, logistics)
+ * - Presets should be distributable as external packages
+ * - Core should NOT know about all possible presets
+ * - Users should extend presets without modifying library code
+ *
+ * ARCHITECTURE:
+ * ```
+ * RangePresetPlugin (interface) - Contract for all presets
+ *     ↓
+ * PresetRegistry (service) - Manages plugin registration
+ *     ↓
+ * PresetEngine (refactored) - Resolves presets via registry
+ *     ↓
+ * DualDateRangeStore - No changes, backward compatible
+ * ```
+ *
+ * USAGE:
+ * ```typescript
+ * // Built-in presets work automatically
+ * store.applyPreset('LAST_7_DAYS'); // ✅ Works
+ *
+ * // Register custom preset
+ * const registry = inject(PresetRegistry);
+ * registry.register({
+ *   key: 'THIS_FISCAL_QUARTER',
+ *   resolve: (clock, adapter) => {
+ *     const now = clock.now();
+ *     const fiscalStart = adapter.startOfMonth(now);
+ *     const fiscalEnd = adapter.endOfMonth(now);
+ *     return { start: fiscalStart, end: fiscalEnd };
+ *   }
+ * });
+ *
+ * // Use custom preset
+ * store.applyPreset('THIS_FISCAL_QUARTER'); // ✅ Works
+ * ```
+ *
+ * EXTERNAL PACKAGES:
+ * ```typescript
+ * // @acme/fiscal-presets package
+ * export const FISCAL_PRESETS: RangePresetPlugin[] = [
+ *   { key: 'FISCAL_Q1', resolve: ... },
+ *   { key: 'FISCAL_Q2', resolve: ... }
+ * ];
+ *
+ * // In app
+ * FISCAL_PRESETS.forEach(p => registry.register(p));
+ * ```
+ */
+import { DateClock } from './date-clock';
+import { DateAdapter } from './date-adapter';
+/**
+ * Date range returned by preset plugins
+ */
+export interface DateRange {
+    /**
+     * Start date of the range (inclusive)
+     */
+    start: Date;
+    /**
+     * End date of the range (inclusive)
+     */
+    end: Date;
+}
+/**
+ * Range Preset Plugin Interface
+ *
+ * All date range presets (built-in or external) implement this interface.
+ *
+ * DESIGN PRINCIPLES:
+ * - **Deterministic**: Given the same clock.now(), always returns same range
+ * - **Timezone-safe**: Uses DateAdapter for all date operations
+ * - **SSR-compatible**: Uses DateClock injection, no global Date()
+ * - **Testable**: Pure function, no side effects
+ *
+ * EXAMPLE - Built-in preset:
+ * ```typescript
+ * const todayPreset: RangePresetPlugin = {
+ *   key: 'TODAY',
+ *   resolve: (clock, adapter) => {
+ *     const now = clock.now();
+ *     const normalized = adapter.normalize(now);
+ *     return { start: normalized, end: normalized };
+ *   }
+ * };
+ * ```
+ *
+ * EXAMPLE - Custom fiscal preset:
+ * ```typescript
+ * const fiscalQuarterPreset: RangePresetPlugin = {
+ *   key: 'THIS_FISCAL_QUARTER',
+ *   resolve: (clock, adapter) => {
+ *     const now = clock.now();
+ *     const month = adapter.getMonth(now); // 0-11
+ *
+ *     // Fiscal year starts in April (month 3)
+ *     const fiscalMonth = (month + 9) % 12; // Offset to fiscal calendar
+ *     const quarterStartMonth = Math.floor(fiscalMonth / 3) * 3;
+ *     const adjustedMonth = (quarterStartMonth - 9 + 12) % 12;
+ *
+ *     const yearOffset = month < 3 ? -1 : 0;
+ *     const year = adapter.getYear(now) + yearOffset;
+ *
+ *     const start = new Date(year, adjustedMonth, 1);
+ *     const end = new Date(year, adjustedMonth + 3, 0);
+ *
+ *     return {
+ *       start: adapter.normalize(start),
+ *       end: adapter.normalize(end)
+ *     };
+ *   }
+ * };
+ * ```
+ *
+ * EXAMPLE - Hotel industry preset:
+ * ```typescript
+ * const checkInWeekPreset: RangePresetPlugin = {
+ *   key: 'CHECK_IN_WEEK',
+ *   resolve: (clock, adapter) => {
+ *     const now = clock.now();
+ *     // Hotel check-ins are Friday to Friday
+ *     const dayOfWeek = adapter.getDayOfWeek(now);
+ *     const daysToFriday = dayOfWeek <= 5 ? 5 - dayOfWeek : 7 - dayOfWeek + 5;
+ *
+ *     const nextFriday = adapter.addDays(now, daysToFriday);
+ *     const followingFriday = adapter.addDays(nextFriday, 7);
+ *
+ *     return { start: nextFriday, end: followingFriday };
+ *   }
+ * };
+ * ```
+ */
+export interface RangePresetPlugin {
+    /**
+     * Unique identifier for the preset
+     *
+     * Convention: SCREAMING_SNAKE_CASE
+     *
+     * Examples:
+     * - Built-in: 'TODAY', 'LAST_7_DAYS', 'THIS_MONTH'
+     * - Fiscal: 'FISCAL_Q1', 'FISCAL_YEAR_TO_DATE'
+     * - Hotel: 'CHECK_IN_WEEK', 'NEXT_30_NIGHTS'
+     * - Logistics: 'SHIPPING_WEEK', 'DELIVERY_WINDOW'
+     */
+    key: string;
+    /**
+     * Resolve the date range for this preset
+     *
+     * MUST use:
+     * - `clock.now()` for current time (SSR-safe, deterministic)
+     * - `adapter.*` for all date operations (timezone-safe)
+     *
+     * MUST NOT use:
+     * - `new Date()` directly (breaks SSR determinism)
+     * - `date.toISOString()` (timezone bugs)
+     * - `date.setDate()` (mutates, use adapter.addDays() instead)
+     *
+     * @param clock - Injected DateClock for SSR-safe time access
+     * @param adapter - Injected DateAdapter for timezone-safe operations
+     * @returns Date range with start and end dates (both inclusive)
+     *
+     * @example
+     * ```typescript
+     * resolve: (clock, adapter) => {
+     *   const now = clock.now();
+     *   const start = adapter.addDays(now, -7);
+     *   const end = adapter.normalize(now);
+     *   return { start, end };
+     * }
+     * ```
+     */
+    resolve(clock: DateClock, adapter: DateAdapter): DateRange;
+}
+/**
+ * Type guard to check if object is a valid RangePresetPlugin
+ *
+ * @param obj - Object to check
+ * @returns true if object implements RangePresetPlugin interface
+ */
+export declare function isRangePresetPlugin(obj: any): obj is RangePresetPlugin;

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/built-in-presets.mjs

@@ -0,0 +1,289 @@
+/**
+ * Built-in Date Range Preset Plugins
+ *
+ * Version: 3.6.0
+ *
+ * Standard presets provided by the library.
+ * All presets use DateClock and DateAdapter for SSR-safety and timezone-safety.
+ *
+ * PRESETS INCLUDED:
+ * - TODAY, YESTERDAY
+ * - LAST_7_DAYS, LAST_14_DAYS, LAST_30_DAYS, LAST_60_DAYS, LAST_90_DAYS
+ * - THIS_WEEK, LAST_WEEK
+ * - THIS_MONTH, LAST_MONTH, MONTH_TO_DATE
+ * - THIS_QUARTER, LAST_QUARTER, QUARTER_TO_DATE
+ * - THIS_YEAR, LAST_YEAR, YEAR_TO_DATE
+ */
+/**
+ * TODAY - Current day
+ */
+export const TODAY_PRESET = {
+    key: 'TODAY',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const normalized = adapter.normalize(now);
+        return { start: normalized, end: normalized };
+    }
+};
+/**
+ * YESTERDAY - Previous day
+ */
+export const YESTERDAY_PRESET = {
+    key: 'YESTERDAY',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const date = adapter.addDays(now, -1);
+        return { start: date, end: date };
+    }
+};
+/**
+ * LAST_7_DAYS - Last 7 days including today
+ */
+export const LAST_7_DAYS_PRESET = {
+    key: 'LAST_7_DAYS',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const end = adapter.normalize(now);
+        const start = adapter.addDays(now, -6);
+        return { start, end };
+    }
+};
+/**
+ * LAST_14_DAYS - Last 14 days including today
+ */
+export const LAST_14_DAYS_PRESET = {
+    key: 'LAST_14_DAYS',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const end = adapter.normalize(now);
+        const start = adapter.addDays(now, -13);
+        return { start, end };
+    }
+};
+/**
+ * LAST_30_DAYS - Last 30 days including today
+ */
+export const LAST_30_DAYS_PRESET = {
+    key: 'LAST_30_DAYS',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const end = adapter.normalize(now);
+        const start = adapter.addDays(now, -29);
+        return { start, end };
+    }
+};
+/**
+ * LAST_60_DAYS - Last 60 days including today
+ */
+export const LAST_60_DAYS_PRESET = {
+    key: 'LAST_60_DAYS',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const end = adapter.normalize(now);
+        const start = adapter.addDays(now, -59);
+        return { start, end };
+    }
+};
+/**
+ * LAST_90_DAYS - Last 90 days including today
+ */
+export const LAST_90_DAYS_PRESET = {
+    key: 'LAST_90_DAYS',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const end = adapter.normalize(now);
+        const start = adapter.addDays(now, -89);
+        return { start, end };
+    }
+};
+/**
+ * THIS_WEEK - Current week (Monday to Sunday)
+ */
+export const THIS_WEEK_PRESET = {
+    key: 'THIS_WEEK',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const dayOfWeek = adapter.getDay(now);
+        const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+        const start = adapter.addDays(now, -daysToMonday);
+        const end = adapter.addDays(start, 6);
+        return { start, end };
+    }
+};
+/**
+ * LAST_WEEK - Previous week (Monday to Sunday)
+ */
+export const LAST_WEEK_PRESET = {
+    key: 'LAST_WEEK',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const dayOfWeek = adapter.getDay(now);
+        const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+        const lastMonday = adapter.addDays(now, -daysToMonday - 7);
+        const lastSunday = adapter.addDays(lastMonday, 6);
+        return { start: lastMonday, end: lastSunday };
+    }
+};
+/**
+ * THIS_MONTH - Current calendar month (1st to last day)
+ */
+export const THIS_MONTH_PRESET = {
+    key: 'THIS_MONTH',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const start = adapter.startOfMonth(now);
+        const end = adapter.endOfMonth(now);
+        return { start, end };
+    }
+};
+/**
+ * LAST_MONTH - Previous calendar month
+ */
+export const LAST_MONTH_PRESET = {
+    key: 'LAST_MONTH',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const lastMonth = adapter.addMonths(now, -1);
+        const start = adapter.startOfMonth(lastMonth);
+        const end = adapter.endOfMonth(lastMonth);
+        return { start, end };
+    }
+};
+/**
+ * MONTH_TO_DATE - From start of current month to today
+ */
+export const MONTH_TO_DATE_PRESET = {
+    key: 'MONTH_TO_DATE',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const start = adapter.startOfMonth(now);
+        const end = adapter.normalize(now);
+        return { start, end };
+    }
+};
+/**
+ * THIS_QUARTER - Current quarter (Q1: Jan-Mar, Q2: Apr-Jun, Q3: Jul-Sep, Q4: Oct-Dec)
+ */
+export const THIS_QUARTER_PRESET = {
+    key: 'THIS_QUARTER',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const currentMonth = adapter.getMonth(now);
+        const quarterStartMonth = Math.floor(currentMonth / 3) * 3;
+        const year = adapter.getYear(now);
+        const start = new Date(year, quarterStartMonth, 1);
+        const normalizedStart = adapter.normalize(start);
+        const end = new Date(year, quarterStartMonth + 3, 0);
+        const normalizedEnd = adapter.normalize(end);
+        return { start: normalizedStart, end: normalizedEnd };
+    }
+};
+/**
+ * LAST_QUARTER - Previous quarter
+ */
+export const LAST_QUARTER_PRESET = {
+    key: 'LAST_QUARTER',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const currentMonth = adapter.getMonth(now);
+        const lastQuarterStartMonth = Math.floor(currentMonth / 3) * 3 - 3;
+        const year = adapter.getYear(now);
+        const adjustedYear = lastQuarterStartMonth < 0 ? year - 1 : year;
+        const adjustedMonth = lastQuarterStartMonth < 0 ? 9 : lastQuarterStartMonth;
+        const start = new Date(adjustedYear, adjustedMonth, 1);
+        const normalizedStart = adapter.normalize(start);
+        const end = new Date(adjustedYear, adjustedMonth + 3, 0);
+        const normalizedEnd = adapter.normalize(end);
+        return { start: normalizedStart, end: normalizedEnd };
+    }
+};
+/**
+ * QUARTER_TO_DATE - From start of current quarter to today
+ */
+export const QUARTER_TO_DATE_PRESET = {
+    key: 'QUARTER_TO_DATE',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const currentMonth = adapter.getMonth(now);
+        const quarterStartMonth = Math.floor(currentMonth / 3) * 3;
+        const year = adapter.getYear(now);
+        const start = new Date(year, quarterStartMonth, 1);
+        const normalizedStart = adapter.normalize(start);
+        const end = adapter.normalize(now);
+        return { start: normalizedStart, end };
+    }
+};
+/**
+ * THIS_YEAR - Current calendar year (Jan 1 to Dec 31)
+ */
+export const THIS_YEAR_PRESET = {
+    key: 'THIS_YEAR',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const year = adapter.getYear(now);
+        const start = new Date(year, 0, 1);
+        const end = new Date(year, 11, 31);
+        return {
+            start: adapter.normalize(start),
+            end: adapter.normalize(end)
+        };
+    }
+};
+/**
+ * LAST_YEAR - Previous calendar year
+ */
+export const LAST_YEAR_PRESET = {
+    key: 'LAST_YEAR',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const year = adapter.getYear(now);
+        const start = new Date(year - 1, 0, 1);
+        const end = new Date(year - 1, 11, 31);
+        return {
+            start: adapter.normalize(start),
+            end: adapter.normalize(end)
+        };
+    }
+};
+/**
+ * YEAR_TO_DATE - From start of current year to today
+ */
+export const YEAR_TO_DATE_PRESET = {
+    key: 'YEAR_TO_DATE',
+    resolve: (clock, adapter) => {
+        const now = clock.now();
+        const year = adapter.getYear(now);
+        const start = new Date(year, 0, 1);
+        const end = adapter.normalize(now);
+        return { start: adapter.normalize(start), end };
+    }
+};
+/**
+ * All built-in presets as an array
+ *
+ * Use this to register all built-in presets at once:
+ * ```typescript
+ * BUILT_IN_PRESETS.forEach(preset => registry.register(preset));
+ * ```
+ */
+export const BUILT_IN_PRESETS = [
+    TODAY_PRESET,
+    YESTERDAY_PRESET,
+    LAST_7_DAYS_PRESET,
+    LAST_14_DAYS_PRESET,
+    LAST_30_DAYS_PRESET,
+    LAST_60_DAYS_PRESET,
+    LAST_90_DAYS_PRESET,
+    THIS_WEEK_PRESET,
+    LAST_WEEK_PRESET,
+    THIS_MONTH_PRESET,
+    LAST_MONTH_PRESET,
+    MONTH_TO_DATE_PRESET,
+    THIS_QUARTER_PRESET,
+    LAST_QUARTER_PRESET,
+    QUARTER_TO_DATE_PRESET,
+    THIS_YEAR_PRESET,
+    LAST_YEAR_PRESET,
+    YEAR_TO_DATE_PRESET
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"built-in-presets.js","sourceRoot":"","sources":["../../../src/core/built-in-presets.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Built-in Date Range Preset Plugins\n * \n * Version: 3.6.0\n * \n * Standard presets provided by the library.\n * All presets use DateClock and DateAdapter for SSR-safety and timezone-safety.\n * \n * PRESETS INCLUDED:\n * - TODAY, YESTERDAY\n * - LAST_7_DAYS, LAST_14_DAYS, LAST_30_DAYS, LAST_60_DAYS, LAST_90_DAYS\n * - THIS_WEEK, LAST_WEEK\n * - THIS_MONTH, LAST_MONTH, MONTH_TO_DATE\n * - THIS_QUARTER, LAST_QUARTER, QUARTER_TO_DATE\n * - THIS_YEAR, LAST_YEAR, YEAR_TO_DATE\n */\n\nimport { RangePresetPlugin } from './range-preset.plugin';\n\n/**\n * TODAY - Current day\n */\nexport const TODAY_PRESET: RangePresetPlugin = {\n  key: 'TODAY',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const normalized = adapter.normalize(now);\n    return { start: normalized, end: normalized };\n  }\n};\n\n/**\n * YESTERDAY - Previous day\n */\nexport const YESTERDAY_PRESET: RangePresetPlugin = {\n  key: 'YESTERDAY',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const date = adapter.addDays(now, -1);\n    return { start: date, end: date };\n  }\n};\n\n/**\n * LAST_7_DAYS - Last 7 days including today\n */\nexport const LAST_7_DAYS_PRESET: RangePresetPlugin = {\n  key: 'LAST_7_DAYS',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const end = adapter.normalize(now);\n    const start = adapter.addDays(now, -6);\n    return { start, end };\n  }\n};\n\n/**\n * LAST_14_DAYS - Last 14 days including today\n */\nexport const LAST_14_DAYS_PRESET: RangePresetPlugin = {\n  key: 'LAST_14_DAYS',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const end = adapter.normalize(now);\n    const start = adapter.addDays(now, -13);\n    return { start, end };\n  }\n};\n\n/**\n * LAST_30_DAYS - Last 30 days including today\n */\nexport const LAST_30_DAYS_PRESET: RangePresetPlugin = {\n  key: 'LAST_30_DAYS',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const end = adapter.normalize(now);\n    const start = adapter.addDays(now, -29);\n    return { start, end };\n  }\n};\n\n/**\n * LAST_60_DAYS - Last 60 days including today\n */\nexport const LAST_60_DAYS_PRESET: RangePresetPlugin = {\n  key: 'LAST_60_DAYS',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const end = adapter.normalize(now);\n    const start = adapter.addDays(now, -59);\n    return { start, end };\n  }\n};\n\n/**\n * LAST_90_DAYS - Last 90 days including today\n */\nexport const LAST_90_DAYS_PRESET: RangePresetPlugin = {\n  key: 'LAST_90_DAYS',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const end = adapter.normalize(now);\n    const start = adapter.addDays(now, -89);\n    return { start, end };\n  }\n};\n\n/**\n * THIS_WEEK - Current week (Monday to Sunday)\n */\nexport const THIS_WEEK_PRESET: RangePresetPlugin = {\n  key: 'THIS_WEEK',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const dayOfWeek = adapter.getDay(now);\n    const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;\n    const start = adapter.addDays(now, -daysToMonday);\n    const end = adapter.addDays(start, 6);\n    return { start, end };\n  }\n};\n\n/**\n * LAST_WEEK - Previous week (Monday to Sunday)\n */\nexport const LAST_WEEK_PRESET: RangePresetPlugin = {\n  key: 'LAST_WEEK',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const dayOfWeek = adapter.getDay(now);\n    const daysToMonday = dayOfWeek === 0 ? 6 : dayOfWeek - 1;\n    const lastMonday = adapter.addDays(now, -daysToMonday - 7);\n    const lastSunday = adapter.addDays(lastMonday, 6);\n    return { start: lastMonday, end: lastSunday };\n  }\n};\n\n/**\n * THIS_MONTH - Current calendar month (1st to last day)\n */\nexport const THIS_MONTH_PRESET: RangePresetPlugin = {\n  key: 'THIS_MONTH',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const start = adapter.startOfMonth(now);\n    const end = adapter.endOfMonth(now);\n    return { start, end };\n  }\n};\n\n/**\n * LAST_MONTH - Previous calendar month\n */\nexport const LAST_MONTH_PRESET: RangePresetPlugin = {\n  key: 'LAST_MONTH',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const lastMonth = adapter.addMonths(now, -1);\n    const start = adapter.startOfMonth(lastMonth);\n    const end = adapter.endOfMonth(lastMonth);\n    return { start, end };\n  }\n};\n\n/**\n * MONTH_TO_DATE - From start of current month to today\n */\nexport const MONTH_TO_DATE_PRESET: RangePresetPlugin = {\n  key: 'MONTH_TO_DATE',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const start = adapter.startOfMonth(now);\n    const end = adapter.normalize(now);\n    return { start, end };\n  }\n};\n\n/**\n * THIS_QUARTER - Current quarter (Q1: Jan-Mar, Q2: Apr-Jun, Q3: Jul-Sep, Q4: Oct-Dec)\n */\nexport const THIS_QUARTER_PRESET: RangePresetPlugin = {\n  key: 'THIS_QUARTER',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const currentMonth = adapter.getMonth(now);\n    const quarterStartMonth = Math.floor(currentMonth / 3) * 3;\n    const year = adapter.getYear(now);\n    \n    const start = new Date(year, quarterStartMonth, 1);\n    const normalizedStart = adapter.normalize(start);\n    \n    const end = new Date(year, quarterStartMonth + 3, 0);\n    const normalizedEnd = adapter.normalize(end);\n    \n    return { start: normalizedStart, end: normalizedEnd };\n  }\n};\n\n/**\n * LAST_QUARTER - Previous quarter\n */\nexport const LAST_QUARTER_PRESET: RangePresetPlugin = {\n  key: 'LAST_QUARTER',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const currentMonth = adapter.getMonth(now);\n    const lastQuarterStartMonth = Math.floor(currentMonth / 3) * 3 - 3;\n    const year = adapter.getYear(now);\n    \n    const adjustedYear = lastQuarterStartMonth < 0 ? year - 1 : year;\n    const adjustedMonth = lastQuarterStartMonth < 0 ? 9 : lastQuarterStartMonth;\n    \n    const start = new Date(adjustedYear, adjustedMonth, 1);\n    const normalizedStart = adapter.normalize(start);\n    \n    const end = new Date(adjustedYear, adjustedMonth + 3, 0);\n    const normalizedEnd = adapter.normalize(end);\n    \n    return { start: normalizedStart, end: normalizedEnd };\n  }\n};\n\n/**\n * QUARTER_TO_DATE - From start of current quarter to today\n */\nexport const QUARTER_TO_DATE_PRESET: RangePresetPlugin = {\n  key: 'QUARTER_TO_DATE',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const currentMonth = adapter.getMonth(now);\n    const quarterStartMonth = Math.floor(currentMonth / 3) * 3;\n    const year = adapter.getYear(now);\n    \n    const start = new Date(year, quarterStartMonth, 1);\n    const normalizedStart = adapter.normalize(start);\n    const end = adapter.normalize(now);\n    \n    return { start: normalizedStart, end };\n  }\n};\n\n/**\n * THIS_YEAR - Current calendar year (Jan 1 to Dec 31)\n */\nexport const THIS_YEAR_PRESET: RangePresetPlugin = {\n  key: 'THIS_YEAR',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const year = adapter.getYear(now);\n    const start = new Date(year, 0, 1);\n    const end = new Date(year, 11, 31);\n    return { \n      start: adapter.normalize(start), \n      end: adapter.normalize(end) \n    };\n  }\n};\n\n/**\n * LAST_YEAR - Previous calendar year\n */\nexport const LAST_YEAR_PRESET: RangePresetPlugin = {\n  key: 'LAST_YEAR',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const year = adapter.getYear(now);\n    const start = new Date(year - 1, 0, 1);\n    const end = new Date(year - 1, 11, 31);\n    return { \n      start: adapter.normalize(start), \n      end: adapter.normalize(end) \n    };\n  }\n};\n\n/**\n * YEAR_TO_DATE - From start of current year to today\n */\nexport const YEAR_TO_DATE_PRESET: RangePresetPlugin = {\n  key: 'YEAR_TO_DATE',\n  resolve: (clock, adapter) => {\n    const now = clock.now();\n    const year = adapter.getYear(now);\n    const start = new Date(year, 0, 1);\n    const end = adapter.normalize(now);\n    return { start: adapter.normalize(start), end };\n  }\n};\n\n/**\n * All built-in presets as an array\n * \n * Use this to register all built-in presets at once:\n * ```typescript\n * BUILT_IN_PRESETS.forEach(preset => registry.register(preset));\n * ```\n */\nexport const BUILT_IN_PRESETS: RangePresetPlugin[] = [\n  TODAY_PRESET,\n  YESTERDAY_PRESET,\n  LAST_7_DAYS_PRESET,\n  LAST_14_DAYS_PRESET,\n  LAST_30_DAYS_PRESET,\n  LAST_60_DAYS_PRESET,\n  LAST_90_DAYS_PRESET,\n  THIS_WEEK_PRESET,\n  LAST_WEEK_PRESET,\n  THIS_MONTH_PRESET,\n  LAST_MONTH_PRESET,\n  MONTH_TO_DATE_PRESET,\n  THIS_QUARTER_PRESET,\n  LAST_QUARTER_PRESET,\n  QUARTER_TO_DATE_PRESET,\n  THIS_YEAR_PRESET,\n  LAST_YEAR_PRESET,\n  YEAR_TO_DATE_PRESET\n];\n"]}