@oneluiz/dual-datepicker 3.5.0 → 3.6.0

package/esm2022/core/native-date-adapter.mjs

@@ -0,0 +1,286 @@
+/**
+ * Native Date Adapter Implementation
+ *
+ * Default adapter using JavaScript Date with timezone-safe operations.
+ *
+ * Zero dependencies. Conservative implementation that:
+ * - Normalizes all dates to start of day (00:00:00.000)
+ * - Uses manual YYYY-MM-DD construction (avoids toISOString() timezone shift)
+ * - Parses ISO dates to local timezone (avoids UTC interpretation)
+ * - Handles month overflow correctly (Jan 31 + 1 month = Feb 28, not Mar 3)
+ * - All comparisons work on normalized dates
+ *
+ * Limitations:
+ * - No timezone awareness (all operations in local timezone)
+ * - No DST-safe calculations across timezone changes
+ * - For advanced timezone needs, use LuxonDateAdapter or DayJSDateAdapter
+ *
+ * Perfect for:
+ * ✅ Most enterprise apps (ERP, POS, BI) where local timezone is sufficient
+ * ✅ Applications without cross-timezone requirements
+ * ✅ Minimizing bundle size (zero deps)
+ * ✅ Simple, predictable date handling
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NativeDateAdapter {
+    /**
+     * Normalize date to start of day (00:00:00.000) in local timezone
+     *
+     * This is the foundation of timezone-safe operations.
+     * All other methods use normalized dates for comparisons.
+     */
+    normalize(date) {
+        const normalized = new Date(date);
+        normalized.setHours(0, 0, 0, 0);
+        return normalized;
+    }
+    /**
+     * Check if two dates are the same calendar day
+     *
+     * Implementation: Compare YYYY-MM-DD components directly
+     * Avoids timezone issues from valueOf() comparisons
+     */
+    isSameDay(a, b) {
+        return (a.getFullYear() === b.getFullYear() &&
+            a.getMonth() === b.getMonth() &&
+            a.getDate() === b.getDate());
+    }
+    /**
+     * Check if date A is before date B (calendar day level)
+     *
+     * Implementation: Compare normalized dates using valueOf()
+     */
+    isBeforeDay(a, b) {
+        return this.normalize(a).valueOf() < this.normalize(b).valueOf();
+    }
+    /**
+     * Check if date A is after date B (calendar day level)
+     *
+     * Implementation: Compare normalized dates using valueOf()
+     */
+    isAfterDay(a, b) {
+        return this.normalize(a).valueOf() > this.normalize(b).valueOf();
+    }
+    /**
+     * Add days to a date
+     *
+     * Implementation: Use setDate() which handles month rollover automatically
+     *
+     * Example:
+     * Jan 31 + 3 days → Feb 3 ✅
+     * Feb 28 + 1 day → Mar 1 ✅ (non-leap year)
+     */
+    addDays(date, days) {
+        const result = new Date(date);
+        result.setDate(result.getDate() + days);
+        return this.normalize(result);
+    }
+    /**
+     * Add months to a date
+     *
+     * CRITICAL: Handles month overflow correctly
+     *
+     * Algorithm:
+     * 1. Add months using setMonth()
+     * 2. If day-of-month changed (overflow), set to last day of target month
+     *
+     * Examples:
+     * - Jan 31 + 1 month → Feb 28 (or Feb 29 in leap year) ✅
+     * - Jan 31 + 2 months → Mar 31 ✅
+     * - Mar 31 + 1 month → Apr 30 ✅
+     * - Dec 31 + 1 month → Jan 31 (next year) ✅
+     */
+    addMonths(date, months) {
+        const result = new Date(date);
+        const originalDay = result.getDate();
+        // Add months
+        result.setMonth(result.getMonth() + months);
+        // Check for day overflow (e.g., Jan 31 → Feb 31 becomes Mar 3)
+        if (result.getDate() !== originalDay) {
+            // Overflow detected: set to last day of target month
+            // Go to 1st of next month, then subtract 1 day
+            result.setDate(0); // Sets to last day of previous month
+        }
+        return this.normalize(result);
+    }
+    /**
+     * Get start of day (00:00:00.000)
+     *
+     * Alias for normalize() with explicit intent
+     */
+    startOfDay(date) {
+        return this.normalize(date);
+    }
+    /**
+     * Get end of day (23:59:59.999)
+     *
+     * Useful for inclusive range queries
+     */
+    endOfDay(date) {
+        const result = new Date(date);
+        result.setHours(23, 59, 59, 999);
+        return result;
+    }
+    /**
+     * Get first day of month (00:00:00.000)
+     */
+    startOfMonth(date) {
+        const result = new Date(date);
+        result.setDate(1);
+        return this.normalize(result);
+    }
+    /**
+     * Get last day of month (23:59:59.999)
+     *
+     * Algorithm: Go to 1st of next month, subtract 1 day
+     */
+    endOfMonth(date) {
+        const result = new Date(date);
+        result.setMonth(result.getMonth() + 1, 0); // Day 0 = last day of previous month
+        return this.endOfDay(result);
+    }
+    /**
+     * Get year (4-digit)
+     */
+    getYear(date) {
+        return date.getFullYear();
+    }
+    /**
+     * Get month (0-11)
+     */
+    getMonth(date) {
+        return date.getMonth();
+    }
+    /**
+     * Get day of month (1-31)
+     */
+    getDate(date) {
+        return date.getDate();
+    }
+    /**
+     * Get day of week (0-6, Sunday=0)
+     */
+    getDay(date) {
+        return date.getDay();
+    }
+    /**
+     * Convert Date to ISO date string (YYYY-MM-DD)
+     *
+     * CRITICAL: DO NOT use toISOString() - it converts to UTC!
+     *
+     * Manual construction ensures local timezone is preserved:
+     *
+     * Example problem with toISOString():
+     * ```
+     * // Local timezone: GMT-6 (CST)
+     * const date = new Date('2026-02-21T23:00:00'); // 11 PM Feb 21 local
+     *
+     * // WRONG ❌
+     * date.toISOString().split('T')[0]
+     * // Returns "2026-02-22" (converted to UTC = Feb 22 05:00 AM)
+     *
+     * // CORRECT ✅
+     * toISODate(date)
+     * // Returns "2026-02-21" (local date preserved)
+     * ```
+     *
+     * Implementation: Build YYYY-MM-DD manually from local date components
+     */
+    toISODate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+    /**
+     * Parse ISO date string (YYYY-MM-DD) to Date
+     *
+     * CRITICAL: DO NOT use new Date(isoString) - may parse as UTC!
+     *
+     * Example problem with Date constructor:
+     * ```
+     * // Local timezone: GMT-6 (CST)
+     *
+     * // WRONG ❌
+     * new Date('2026-02-21')
+     * // Parsed as UTC: 2026-02-21T00:00:00Z
+     * // In local timezone: Feb 20, 2026 6:00 PM (previous day!)
+     *
+     * // CORRECT ✅
+     * parseISODate('2026-02-21')
+     * // Returns: 2026-02-21T00:00:00 local time
+     * ```
+     *
+     * Implementation: Parse components and construct Date in local timezone
+     */
+    parseISODate(isoDate) {
+        if (!isoDate || typeof isoDate !== 'string') {
+            return null;
+        }
+        // Match YYYY-MM-DD format
+        const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDate.trim());
+        if (!match) {
+            return null;
+        }
+        const year = parseInt(match[1], 10);
+        const month = parseInt(match[2], 10) - 1; // 0-indexed
+        const day = parseInt(match[3], 10);
+        // Validate ranges
+        if (month < 0 || month > 11) {
+            return null;
+        }
+        if (day < 1 || day > 31) {
+            return null;
+        }
+        // Construct date in local timezone
+        const date = new Date(year, month, day);
+        // Verify date is valid (e.g., Feb 31 would roll to Mar 3)
+        if (date.getFullYear() !== year ||
+            date.getMonth() !== month ||
+            date.getDate() !== day) {
+            return null;
+        }
+        return this.normalize(date);
+    }
+    /**
+     * Get week start day for locale
+     *
+     * Default: Sunday (0) for most locales
+     * Monday (1) for Europe, ISO 8601
+     *
+     * Implementation: Simple locale detection
+     * For advanced needs, use Intl.Locale or external library
+     */
+    getWeekStart(locale) {
+        if (!locale) {
+            locale = typeof navigator !== 'undefined' ? navigator.language : 'en-US';
+        }
+        // ISO 8601: Monday start
+        const mondayStartLocales = [
+            'en-GB', 'en-IE', 'en-AU', 'en-NZ', 'en-CA',
+            'es', 'es-ES', 'es-MX',
+            'fr', 'fr-FR', 'fr-CA',
+            'de', 'de-DE', 'de-AT', 'de-CH',
+            'it', 'it-IT',
+            'pt', 'pt-PT', 'pt-BR',
+            'nl', 'nl-NL', 'nl-BE',
+            'ru', 'ru-RU',
+            'zh', 'zh-CN', 'zh-TW',
+            'ja', 'ja-JP',
+            'ko', 'ko-KR'
+        ];
+        const normalizedLocale = locale.toLowerCase();
+        const startsWithMonday = mondayStartLocales.some(loc => normalizedLocale.startsWith(loc.toLowerCase()));
+        return startsWithMonday ? 1 : 0;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NativeDateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NativeDateAdapter, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NativeDateAdapter, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-date-adapter.js","sourceRoot":"","sources":["../../../src/core/native-date-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Native Date Adapter Implementation\n * \n * Default adapter using JavaScript Date with timezone-safe operations.\n * \n * Zero dependencies. Conservative implementation that:\n * - Normalizes all dates to start of day (00:00:00.000)\n * - Uses manual YYYY-MM-DD construction (avoids toISOString() timezone shift)\n * - Parses ISO dates to local timezone (avoids UTC interpretation)\n * - Handles month overflow correctly (Jan 31 + 1 month = Feb 28, not Mar 3)\n * - All comparisons work on normalized dates\n * \n * Limitations:\n * - No timezone awareness (all operations in local timezone)\n * - No DST-safe calculations across timezone changes\n * - For advanced timezone needs, use LuxonDateAdapter or DayJSDateAdapter\n * \n * Perfect for:\n * ✅ Most enterprise apps (ERP, POS, BI) where local timezone is sufficient\n * ✅ Applications without cross-timezone requirements\n * ✅ Minimizing bundle size (zero deps)\n * ✅ Simple, predictable date handling\n */\n\nimport { Injectable } from '@angular/core';\nimport { DateAdapter } from './date-adapter';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NativeDateAdapter implements DateAdapter {\n  /**\n   * Normalize date to start of day (00:00:00.000) in local timezone\n   * \n   * This is the foundation of timezone-safe operations.\n   * All other methods use normalized dates for comparisons.\n   */\n  normalize(date: Date): Date {\n    const normalized = new Date(date);\n    normalized.setHours(0, 0, 0, 0);\n    return normalized;\n  }\n\n  /**\n   * Check if two dates are the same calendar day\n   * \n   * Implementation: Compare YYYY-MM-DD components directly\n   * Avoids timezone issues from valueOf() comparisons\n   */\n  isSameDay(a: Date, b: Date): boolean {\n    return (\n      a.getFullYear() === b.getFullYear() &&\n      a.getMonth() === b.getMonth() &&\n      a.getDate() === b.getDate()\n    );\n  }\n\n  /**\n   * Check if date A is before date B (calendar day level)\n   * \n   * Implementation: Compare normalized dates using valueOf()\n   */\n  isBeforeDay(a: Date, b: Date): boolean {\n    return this.normalize(a).valueOf() < this.normalize(b).valueOf();\n  }\n\n  /**\n   * Check if date A is after date B (calendar day level)\n   * \n   * Implementation: Compare normalized dates using valueOf()\n   */\n  isAfterDay(a: Date, b: Date): boolean {\n    return this.normalize(a).valueOf() > this.normalize(b).valueOf();\n  }\n\n  /**\n   * Add days to a date\n   * \n   * Implementation: Use setDate() which handles month rollover automatically\n   * \n   * Example:\n   * Jan 31 + 3 days → Feb 3 ✅\n   * Feb 28 + 1 day → Mar 1 ✅ (non-leap year)\n   */\n  addDays(date: Date, days: number): Date {\n    const result = new Date(date);\n    result.setDate(result.getDate() + days);\n    return this.normalize(result);\n  }\n\n  /**\n   * Add months to a date\n   * \n   * CRITICAL: Handles month overflow correctly\n   * \n   * Algorithm:\n   * 1. Add months using setMonth()\n   * 2. If day-of-month changed (overflow), set to last day of target month\n   * \n   * Examples:\n   * - Jan 31 + 1 month → Feb 28 (or Feb 29 in leap year) ✅\n   * - Jan 31 + 2 months → Mar 31 ✅\n   * - Mar 31 + 1 month → Apr 30 ✅\n   * - Dec 31 + 1 month → Jan 31 (next year) ✅\n   */\n  addMonths(date: Date, months: number): Date {\n    const result = new Date(date);\n    const originalDay = result.getDate();\n    \n    // Add months\n    result.setMonth(result.getMonth() + months);\n    \n    // Check for day overflow (e.g., Jan 31 → Feb 31 becomes Mar 3)\n    if (result.getDate() !== originalDay) {\n      // Overflow detected: set to last day of target month\n      // Go to 1st of next month, then subtract 1 day\n      result.setDate(0); // Sets to last day of previous month\n    }\n    \n    return this.normalize(result);\n  }\n\n  /**\n   * Get start of day (00:00:00.000)\n   * \n   * Alias for normalize() with explicit intent\n   */\n  startOfDay(date: Date): Date {\n    return this.normalize(date);\n  }\n\n  /**\n   * Get end of day (23:59:59.999)\n   * \n   * Useful for inclusive range queries\n   */\n  endOfDay(date: Date): Date {\n    const result = new Date(date);\n    result.setHours(23, 59, 59, 999);\n    return result;\n  }\n\n  /**\n   * Get first day of month (00:00:00.000)\n   */\n  startOfMonth(date: Date): Date {\n    const result = new Date(date);\n    result.setDate(1);\n    return this.normalize(result);\n  }\n\n  /**\n   * Get last day of month (23:59:59.999)\n   * \n   * Algorithm: Go to 1st of next month, subtract 1 day\n   */\n  endOfMonth(date: Date): Date {\n    const result = new Date(date);\n    result.setMonth(result.getMonth() + 1, 0); // Day 0 = last day of previous month\n    return this.endOfDay(result);\n  }\n\n  /**\n   * Get year (4-digit)\n   */\n  getYear(date: Date): number {\n    return date.getFullYear();\n  }\n\n  /**\n   * Get month (0-11)\n   */\n  getMonth(date: Date): number {\n    return date.getMonth();\n  }\n\n  /**\n   * Get day of month (1-31)\n   */\n  getDate(date: Date): number {\n    return date.getDate();\n  }\n\n  /**\n   * Get day of week (0-6, Sunday=0)\n   */\n  getDay(date: Date): number {\n    return date.getDay();\n  }\n\n  /**\n   * Convert Date to ISO date string (YYYY-MM-DD)\n   * \n   * CRITICAL: DO NOT use toISOString() - it converts to UTC!\n   * \n   * Manual construction ensures local timezone is preserved:\n   * \n   * Example problem with toISOString():\n   * ```\n   * // Local timezone: GMT-6 (CST)\n   * const date = new Date('2026-02-21T23:00:00'); // 11 PM Feb 21 local\n   * \n   * // WRONG ❌\n   * date.toISOString().split('T')[0]\n   * // Returns \"2026-02-22\" (converted to UTC = Feb 22 05:00 AM)\n   * \n   * // CORRECT ✅\n   * toISODate(date)\n   * // Returns \"2026-02-21\" (local date preserved)\n   * ```\n   * \n   * Implementation: Build YYYY-MM-DD manually from local date components\n   */\n  toISODate(date: Date): string {\n    const year = date.getFullYear();\n    const month = String(date.getMonth() + 1).padStart(2, '0');\n    const day = String(date.getDate()).padStart(2, '0');\n    return `${year}-${month}-${day}`;\n  }\n\n  /**\n   * Parse ISO date string (YYYY-MM-DD) to Date\n   * \n   * CRITICAL: DO NOT use new Date(isoString) - may parse as UTC!\n   * \n   * Example problem with Date constructor:\n   * ```\n   * // Local timezone: GMT-6 (CST)\n   * \n   * // WRONG ❌\n   * new Date('2026-02-21')\n   * // Parsed as UTC: 2026-02-21T00:00:00Z\n   * // In local timezone: Feb 20, 2026 6:00 PM (previous day!)\n   * \n   * // CORRECT ✅\n   * parseISODate('2026-02-21')\n   * // Returns: 2026-02-21T00:00:00 local time\n   * ```\n   * \n   * Implementation: Parse components and construct Date in local timezone\n   */\n  parseISODate(isoDate: string): Date | null {\n    if (!isoDate || typeof isoDate !== 'string') {\n      return null;\n    }\n\n    // Match YYYY-MM-DD format\n    const match = /^(\\d{4})-(\\d{2})-(\\d{2})$/.exec(isoDate.trim());\n    \n    if (!match) {\n      return null;\n    }\n\n    const year = parseInt(match[1], 10);\n    const month = parseInt(match[2], 10) - 1; // 0-indexed\n    const day = parseInt(match[3], 10);\n\n    // Validate ranges\n    if (month < 0 || month > 11) {\n      return null;\n    }\n\n    if (day < 1 || day > 31) {\n      return null;\n    }\n\n    // Construct date in local timezone\n    const date = new Date(year, month, day);\n    \n    // Verify date is valid (e.g., Feb 31 would roll to Mar 3)\n    if (\n      date.getFullYear() !== year ||\n      date.getMonth() !== month ||\n      date.getDate() !== day\n    ) {\n      return null;\n    }\n\n    return this.normalize(date);\n  }\n\n  /**\n   * Get week start day for locale\n   * \n   * Default: Sunday (0) for most locales\n   * Monday (1) for Europe, ISO 8601\n   * \n   * Implementation: Simple locale detection\n   * For advanced needs, use Intl.Locale or external library\n   */\n  getWeekStart(locale?: string): 0 | 1 | 2 | 3 | 4 | 5 | 6 {\n    if (!locale) {\n      locale = typeof navigator !== 'undefined' ? navigator.language : 'en-US';\n    }\n\n    // ISO 8601: Monday start\n    const mondayStartLocales = [\n      'en-GB', 'en-IE', 'en-AU', 'en-NZ', 'en-CA',\n      'es', 'es-ES', 'es-MX',\n      'fr', 'fr-FR', 'fr-CA',\n      'de', 'de-DE', 'de-AT', 'de-CH',\n      'it', 'it-IT',\n      'pt', 'pt-PT', 'pt-BR',\n      'nl', 'nl-NL', 'nl-BE',\n      'ru', 'ru-RU',\n      'zh', 'zh-CN', 'zh-TW',\n      'ja', 'ja-JP',\n      'ko', 'ko-KR'\n    ];\n\n    const normalizedLocale = locale.toLowerCase();\n    const startsWithMonday = mondayStartLocales.some(loc => \n      normalizedLocale.startsWith(loc.toLowerCase())\n    );\n\n    return startsWithMonday ? 1 : 0;\n  }\n}\n"]}

package/esm2022/core/preset-providers.mjs

@@ -0,0 +1,243 @@
+/**
+ * Provider Functions for Built-in Presets
+ *
+ * Version: 3.6.0
+ *
+ * Automatic registration of built-in date range presets.
+ * These providers ensure backward compatibility by auto-registering
+ * all standard presets (TODAY, LAST_7_DAYS, THIS_MONTH, etc.)
+ *
+ * USAGE IN LIBRARY (Internal):
+ * Built-in presets are registered automatically via Angular providers.
+ * Library consumers don't need to do anything.
+ *
+ * USAGE IN APP (Custom Presets):
+ * ```typescript
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     // ... other providers
+ *     provideCustomPresets([
+ *       {
+ *         key: 'THIS_FISCAL_QUARTER',
+ *         resolve: (clock, adapter) => {
+ *           const now = clock.now();
+ *           // ... fiscal logic
+ *           return { start, end };
+ *         }
+ *       }
+ *     ])
+ *   ]
+ * };
+ * ```
+ */
+import { APP_INITIALIZER, makeEnvironmentProviders } from '@angular/core';
+import { PresetRegistry } from './preset-registry';
+import { BUILT_IN_PRESETS } from './built-in-presets';
+/**
+ * Initializer function that registers built-in presets
+ *
+ * Runs at application startup (APP_INITIALIZER)
+ *
+ * @param registry - PresetRegistry instance
+ * @returns Initialization function
+ */
+function initializeBuiltInPresets(registry) {
+    return () => {
+        // Register all built-in presets
+        BUILT_IN_PRESETS.forEach(preset => {
+            registry.register(preset);
+        });
+        // Log registration for debugging (can be removed in production)
+        if (typeof console !== 'undefined' && console.debug) {
+            console.debug(`[ng-dual-datepicker] Registered ${BUILT_IN_PRESETS.length} built-in presets:`, BUILT_IN_PRESETS.map(p => p.key).join(', '));
+        }
+    };
+}
+/**
+ * Provide built-in date range presets
+ *
+ * This provider is automatically included in the library's root providers.
+ * Library consumers don't need to add this manually.
+ *
+ * @returns EnvironmentProviders for built-in presets
+ *
+ * @internal
+ */
+export function provideBuiltInPresets() {
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: initializeBuiltInPresets,
+            deps: [PresetRegistry]
+        }
+    ]);
+}
+/**
+ * Provide custom date range presets
+ *
+ * Use this to register your own industry-specific presets:
+ * - Fiscal presets
+ * - Hotel/hospitality presets
+ * - Logistics presets
+ * - Custom business logic
+ *
+ * @param presets - Array of custom RangePresetPlugin implementations
+ * @returns EnvironmentProviders for custom presets
+ *
+ * @example
+ * ```typescript
+ * // Fiscal presets
+ * const FISCAL_PRESETS: RangePresetPlugin[] = [
+ *   {
+ *     key: 'THIS_FISCAL_QUARTER',
+ *     resolve: (clock, adapter) => {
+ *       const now = clock.now();
+ *       const month = adapter.getMonth(now);
+ *
+ *       // Fiscal year starts April (month 3)
+ *       const fiscalMonth = (month + 9) % 12;
+ *       const quarterStart = Math.floor(fiscalMonth / 3) * 3;
+ *       const calendarMonth = (quarterStart - 9 + 12) % 12;
+ *
+ *       const year = adapter.getYear(now);
+ *       const fiscalYear = month < 3 ? year - 1 : year;
+ *
+ *       const start = new Date(fiscalYear, calendarMonth, 1);
+ *       const end = new Date(fiscalYear, calendarMonth + 3, 0);
+ *
+ *       return {
+ *         start: adapter.normalize(start),
+ *         end: adapter.normalize(end)
+ *       };
+ *     }
+ *   },
+ *   {
+ *     key: 'FISCAL_YEAR_TO_DATE',
+ *     resolve: (clock, adapter) => {
+ *       const now = clock.now();
+ *       const month = adapter.getMonth(now);
+ *       const year = adapter.getYear(now);
+ *
+ *       // Fiscal year starts April 1
+ *       const fiscalYearStart = month >= 3
+ *         ? new Date(year, 3, 1)
+ *         : new Date(year - 1, 3, 1);
+ *
+ *       return {
+ *         start: adapter.normalize(fiscalYearStart),
+ *         end: adapter.normalize(now)
+ *       };
+ *     }
+ *   }
+ * ];
+ *
+ * // In app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideCustomPresets(FISCAL_PRESETS)
+ *   ]
+ * };
+ *
+ * // Use in components
+ * store.applyPreset('THIS_FISCAL_QUARTER');
+ * store.applyPreset('FISCAL_YEAR_TO_DATE');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Hotel presets
+ * const HOTEL_PRESETS: RangePresetPlugin[] = [
+ *   {
+ *     key: 'CHECK_IN_WEEK',
+ *     resolve: (clock, adapter) => {
+ *       const now = clock.now();
+ *       const dayOfWeek = adapter.getDayOfWeek(now);
+ *
+ *       // Check-in week: Friday to Friday
+ *       const daysToNextFriday = dayOfWeek <= 5
+ *         ? 5 - dayOfWeek
+ *         : 7 - dayOfWeek + 5;
+ *
+ *       const nextFriday = adapter.addDays(now, daysToNextFriday);
+ *       const followingFriday = adapter.addDays(nextFriday, 7);
+ *
+ *       return { start: nextFriday, end: followingFriday };
+ *     }
+ *   },
+ *   {
+ *     key: 'NEXT_30_NIGHTS',
+ *     resolve: (clock, adapter) => {
+ *       const now = clock.now();
+ *       const tomorrow = adapter.addDays(now, 1);
+ *       const end = adapter.addDays(tomorrow, 30);
+ *       return { start: tomorrow, end };
+ *     }
+ *   }
+ * ];
+ *
+ * providers: [provideCustomPresets(HOTEL_PRESETS)]
+ * ```
+ */
+export function provideCustomPresets(presets) {
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: (registry) => {
+                return () => {
+                    presets.forEach(preset => {
+                        registry.register(preset);
+                    });
+                    if (typeof console !== 'undefined' && console.debug) {
+                        console.debug(`[ng-dual-datepicker] Registered ${presets.length} custom presets:`, presets.map(p => p.key).join(', '));
+                    }
+                };
+            },
+            deps: [PresetRegistry]
+        }
+    ]);
+}
+/**
+ * Provide preset package
+ *
+ * Convenience function for external preset packages.
+ *
+ * @param packageName - Name of the preset package (for logging)
+ * @param presets - Array of presets from the package
+ * @returns EnvironmentProviders
+ *
+ * @example
+ * ```typescript
+ * // @acme/fiscal-presets package
+ * export function provideFiscalPresets(): EnvironmentProviders {
+ *   return providePresetPackage('@acme/fiscal-presets', FISCAL_PRESETS);
+ * }
+ *
+ * // In app
+ * import { provideFiscalPresets } from '@acme/fiscal-presets';
+ *
+ * providers: [provideFiscalPresets()]
+ * ```
+ */
+export function providePresetPackage(packageName, presets) {
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: (registry) => {
+                return () => {
+                    presets.forEach(preset => {
+                        registry.register(preset);
+                    });
+                    if (typeof console !== 'undefined' && console.debug) {
+                        console.debug(`[${packageName}] Registered ${presets.length} presets:`, presets.map(p => p.key).join(', '));
+                    }
+                };
+            },
+            deps: [PresetRegistry]
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset-providers.js","sourceRoot":"","sources":["../../../src/core/preset-providers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Provider Functions for Built-in Presets\n * \n * Version: 3.6.0\n * \n * Automatic registration of built-in date range presets.\n * These providers ensure backward compatibility by auto-registering\n * all standard presets (TODAY, LAST_7_DAYS, THIS_MONTH, etc.)\n * \n * USAGE IN LIBRARY (Internal):\n * Built-in presets are registered automatically via Angular providers.\n * Library consumers don't need to do anything.\n * \n * USAGE IN APP (Custom Presets):\n * ```typescript\n * // app.config.ts\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     // ... other providers\n *     provideCustomPresets([\n *       {\n *         key: 'THIS_FISCAL_QUARTER',\n *         resolve: (clock, adapter) => {\n *           const now = clock.now();\n *           // ... fiscal logic\n *           return { start, end };\n *         }\n *       }\n *     ])\n *   ]\n * };\n * ```\n */\n\nimport { APP_INITIALIZER, EnvironmentProviders, makeEnvironmentProviders, inject } from '@angular/core';\nimport { PresetRegistry } from './preset-registry';\nimport { BUILT_IN_PRESETS } from './built-in-presets';\nimport { RangePresetPlugin } from './range-preset.plugin';\n\n/**\n * Initializer function that registers built-in presets\n * \n * Runs at application startup (APP_INITIALIZER)\n * \n * @param registry - PresetRegistry instance\n * @returns Initialization function\n */\nfunction initializeBuiltInPresets(registry: PresetRegistry): () => void {\n  return () => {\n    // Register all built-in presets\n    BUILT_IN_PRESETS.forEach(preset => {\n      registry.register(preset);\n    });\n\n    // Log registration for debugging (can be removed in production)\n    if (typeof console !== 'undefined' && console.debug) {\n      console.debug(\n        `[ng-dual-datepicker] Registered ${BUILT_IN_PRESETS.length} built-in presets:`,\n        BUILT_IN_PRESETS.map(p => p.key).join(', ')\n      );\n    }\n  };\n}\n\n/**\n * Provide built-in date range presets\n * \n * This provider is automatically included in the library's root providers.\n * Library consumers don't need to add this manually.\n * \n * @returns EnvironmentProviders for built-in presets\n * \n * @internal\n */\nexport function provideBuiltInPresets(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: APP_INITIALIZER,\n      multi: true,\n      useFactory: initializeBuiltInPresets,\n      deps: [PresetRegistry]\n    }\n  ]);\n}\n\n/**\n * Provide custom date range presets\n * \n * Use this to register your own industry-specific presets:\n * - Fiscal presets\n * - Hotel/hospitality presets\n * - Logistics presets\n * - Custom business logic\n * \n * @param presets - Array of custom RangePresetPlugin implementations\n * @returns EnvironmentProviders for custom presets\n * \n * @example\n * ```typescript\n * // Fiscal presets\n * const FISCAL_PRESETS: RangePresetPlugin[] = [\n *   {\n *     key: 'THIS_FISCAL_QUARTER',\n *     resolve: (clock, adapter) => {\n *       const now = clock.now();\n *       const month = adapter.getMonth(now);\n *       \n *       // Fiscal year starts April (month 3)\n *       const fiscalMonth = (month + 9) % 12;\n *       const quarterStart = Math.floor(fiscalMonth / 3) * 3;\n *       const calendarMonth = (quarterStart - 9 + 12) % 12;\n *       \n *       const year = adapter.getYear(now);\n *       const fiscalYear = month < 3 ? year - 1 : year;\n *       \n *       const start = new Date(fiscalYear, calendarMonth, 1);\n *       const end = new Date(fiscalYear, calendarMonth + 3, 0);\n *       \n *       return {\n *         start: adapter.normalize(start),\n *         end: adapter.normalize(end)\n *       };\n *     }\n *   },\n *   {\n *     key: 'FISCAL_YEAR_TO_DATE',\n *     resolve: (clock, adapter) => {\n *       const now = clock.now();\n *       const month = adapter.getMonth(now);\n *       const year = adapter.getYear(now);\n *       \n *       // Fiscal year starts April 1\n *       const fiscalYearStart = month >= 3 \n *         ? new Date(year, 3, 1)\n *         : new Date(year - 1, 3, 1);\n *       \n *       return {\n *         start: adapter.normalize(fiscalYearStart),\n *         end: adapter.normalize(now)\n *       };\n *     }\n *   }\n * ];\n * \n * // In app.config.ts\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideCustomPresets(FISCAL_PRESETS)\n *   ]\n * };\n * \n * // Use in components\n * store.applyPreset('THIS_FISCAL_QUARTER');\n * store.applyPreset('FISCAL_YEAR_TO_DATE');\n * ```\n * \n * @example\n * ```typescript\n * // Hotel presets\n * const HOTEL_PRESETS: RangePresetPlugin[] = [\n *   {\n *     key: 'CHECK_IN_WEEK',\n *     resolve: (clock, adapter) => {\n *       const now = clock.now();\n *       const dayOfWeek = adapter.getDayOfWeek(now);\n *       \n *       // Check-in week: Friday to Friday\n *       const daysToNextFriday = dayOfWeek <= 5 \n *         ? 5 - dayOfWeek \n *         : 7 - dayOfWeek + 5;\n *       \n *       const nextFriday = adapter.addDays(now, daysToNextFriday);\n *       const followingFriday = adapter.addDays(nextFriday, 7);\n *       \n *       return { start: nextFriday, end: followingFriday };\n *     }\n *   },\n *   {\n *     key: 'NEXT_30_NIGHTS',\n *     resolve: (clock, adapter) => {\n *       const now = clock.now();\n *       const tomorrow = adapter.addDays(now, 1);\n *       const end = adapter.addDays(tomorrow, 30);\n *       return { start: tomorrow, end };\n *     }\n *   }\n * ];\n * \n * providers: [provideCustomPresets(HOTEL_PRESETS)]\n * ```\n */\nexport function provideCustomPresets(presets: RangePresetPlugin[]): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: APP_INITIALIZER,\n      multi: true,\n      useFactory: (registry: PresetRegistry) => {\n        return () => {\n          presets.forEach(preset => {\n            registry.register(preset);\n          });\n\n          if (typeof console !== 'undefined' && console.debug) {\n            console.debug(\n              `[ng-dual-datepicker] Registered ${presets.length} custom presets:`,\n              presets.map(p => p.key).join(', ')\n            );\n          }\n        };\n      },\n      deps: [PresetRegistry]\n    }\n  ]);\n}\n\n/**\n * Provide preset package\n * \n * Convenience function for external preset packages.\n * \n * @param packageName - Name of the preset package (for logging)\n * @param presets - Array of presets from the package\n * @returns EnvironmentProviders\n * \n * @example\n * ```typescript\n * // @acme/fiscal-presets package\n * export function provideFiscalPresets(): EnvironmentProviders {\n *   return providePresetPackage('@acme/fiscal-presets', FISCAL_PRESETS);\n * }\n * \n * // In app\n * import { provideFiscalPresets } from '@acme/fiscal-presets';\n * \n * providers: [provideFiscalPresets()]\n * ```\n */\nexport function providePresetPackage(\n  packageName: string,\n  presets: RangePresetPlugin[]\n): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: APP_INITIALIZER,\n      multi: true,\n      useFactory: (registry: PresetRegistry) => {\n        return () => {\n          presets.forEach(preset => {\n            registry.register(preset);\n          });\n\n          if (typeof console !== 'undefined' && console.debug) {\n            console.debug(\n              `[${packageName}] Registered ${presets.length} presets:`,\n              presets.map(p => p.key).join(', ')\n            );\n          }\n        };\n      },\n      deps: [PresetRegistry]\n    }\n  ]);\n}\n"]}