@oneluiz/dual-datepicker 3.5.1 → 3.9.0

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"]}

package/esm2022/core/preset-registry.mjs

@@ -0,0 +1,277 @@
+/**
+ * Preset Registry Service
+ *
+ * Version: 3.6.0
+ *
+ * Central registry for all date range preset plugins (built-in and custom).
+ *
+ * ARCHITECTURE:
+ * - Singleton service (providedIn: 'root')
+ * - Manages Map<string, RangePresetPlugin>
+ * - Thread-safe registration
+ * - Supports plugin override (useful for testing)
+ *
+ * USAGE:
+ * ```typescript
+ * // In app
+ * const registry = inject(PresetRegistry);
+ *
+ * // Register custom preset
+ * registry.register({
+ *   key: 'MY_CUSTOM_PRESET',
+ *   resolve: (clock, adapter) => {
+ *     const now = clock.now();
+ *     return { start: now, end: now };
+ *   }
+ * });
+ *
+ * // Check if preset exists
+ * if (registry.has('MY_CUSTOM_PRESET')) {
+ *   store.applyPreset('MY_CUSTOM_PRESET');
+ * }
+ *
+ * // Get all registered presets
+ * const allPresets = registry.getAll();
+ * console.log('Available presets:', allPresets.map(p => p.key));
+ * ```
+ *
+ * EXTERNAL PACKAGES:
+ * ```typescript
+ * // @acme/fiscal-presets
+ * export function provideFiscalPresets() {
+ *   return {
+ *     provide: APP_INITIALIZER,
+ *     multi: true,
+ *     useFactory: (registry: PresetRegistry) => {
+ *       return () => {
+ *         FISCAL_PRESETS.forEach(p => registry.register(p));
+ *       };
+ *     },
+ *     deps: [PresetRegistry]
+ *   };
+ * }
+ * ```
+ */
+import { Injectable } from '@angular/core';
+import { isRangePresetPlugin } from './range-preset.plugin';
+import * as i0 from "@angular/core";
+/**
+ * Preset Registry Service
+ *
+ * Manages registration and retrieval of date range preset plugins.
+ *
+ * DESIGN:
+ * - Uses Map for O(1) lookups
+ * - Immutable getAll() returns copy
+ * - Supports plugin override (last registration wins)
+ * - Validates plugins before registration
+ */
+export class PresetRegistry {
+    /**
+     * Internal map of registered presets
+     * Key: preset key (e.g., 'TODAY', 'LAST_7_DAYS')
+     * Value: RangePresetPlugin instance
+     */
+    presets = new Map();
+    /**
+     * Register a date range preset plugin
+     *
+     * If a preset with the same key already exists, it will be overridden.
+     * This is useful for:
+     * - Testing (override built-in presets with mocks)
+     * - Customization (replace default behavior)
+     * - Hot-reload scenarios
+     *
+     * @param plugin - The preset plugin to register
+     * @throws Error if plugin is invalid (missing key or resolve function)
+     *
+     * @example
+     * ```typescript
+     * registry.register({
+     *   key: 'LAST_BUSINESS_WEEK',
+     *   resolve: (clock, adapter) => {
+     *     const now = clock.now();
+     *     const dayOfWeek = adapter.getDayOfWeek(now);
+     *
+     *     // Go back to last Friday
+     *     const daysToLastFriday = dayOfWeek === 0 ? 2 : (dayOfWeek + 2) % 7;
+     *     const lastFriday = adapter.addDays(now, -daysToLastFriday);
+     *
+     *     // Business week: Monday to Friday
+     *     const monday = adapter.addDays(lastFriday, -4);
+     *
+     *     return { start: monday, end: lastFriday };
+     *   }
+     * });
+     * ```
+     */
+    register(plugin) {
+        // Validate plugin
+        if (!isRangePresetPlugin(plugin)) {
+            throw new Error(`Invalid preset plugin: must have 'key' (string) and 'resolve' (function). ` +
+                `Received: ${JSON.stringify(plugin)}`);
+        }
+        // Validate key is not empty
+        if (!plugin.key || plugin.key.trim().length === 0) {
+            throw new Error('Preset plugin key cannot be empty');
+        }
+        // Register (override if exists)
+        const key = plugin.key.toUpperCase(); // Normalize to uppercase
+        // Warn if overriding
+        if (this.presets.has(key)) {
+            console.warn(`[PresetRegistry] Overriding existing preset: "${key}". ` +
+                `This is normal if you're customizing built-in presets.`);
+        }
+        this.presets.set(key, plugin);
+    }
+    /**
+     * Register multiple preset plugins at once
+     *
+     * Convenience method for bulk registration.
+     * Useful when importing preset packages.
+     *
+     * @param plugins - Array of preset plugins to register
+     *
+     * @example
+     * ```typescript
+     * import { FISCAL_PRESETS } from '@acme/fiscal-presets';
+     *
+     * registry.registerAll(FISCAL_PRESETS);
+     * ```
+     */
+    registerAll(plugins) {
+        plugins.forEach(plugin => this.register(plugin));
+    }
+    /**
+     * Get a preset plugin by key
+     *
+     * @param key - Preset key (case-insensitive, e.g., 'today' or 'TODAY')
+     * @returns The preset plugin or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const preset = registry.get('LAST_7_DAYS');
+     * if (preset) {
+     *   const range = preset.resolve(clock, adapter);
+     *   console.log('Range:', range);
+     * }
+     * ```
+     */
+    get(key) {
+        return this.presets.get(key.toUpperCase());
+    }
+    /**
+     * Check if a preset exists in the registry
+     *
+     * @param key - Preset key (case-insensitive)
+     * @returns true if preset exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.has('THIS_FISCAL_QUARTER')) {
+     *   store.applyPreset('THIS_FISCAL_QUARTER');
+     * } else {
+     *   console.error('Fiscal quarter preset not registered');
+     * }
+     * ```
+     */
+    has(key) {
+        return this.presets.has(key.toUpperCase());
+    }
+    /**
+     * Get all registered preset plugins
+     *
+     * Returns a NEW array (immutable) to prevent external modification.
+     *
+     * @returns Array of all registered preset plugins
+     *
+     * @example
+     * ```typescript
+     * const allPresets = registry.getAll();
+     * console.log('Available presets:');
+     * allPresets.forEach(preset => {
+     *   console.log(`- ${preset.key}`);
+     * });
+     * ```
+     */
+    getAll() {
+        return Array.from(this.presets.values());
+    }
+    /**
+     * Get all preset keys
+     *
+     * Convenience method to list available preset identifiers.
+     *
+     * @returns Array of preset keys (uppercase)
+     *
+     * @example
+     * ```typescript
+     * const keys = registry.getAllKeys();
+     * // ['TODAY', 'YESTERDAY', 'LAST_7_DAYS', 'THIS_MONTH', ...]
+     * ```
+     */
+    getAllKeys() {
+        return Array.from(this.presets.keys());
+    }
+    /**
+     * Get count of registered presets
+     *
+     * @returns Number of registered presets
+     *
+     * @example
+     * ```typescript
+     * console.log(`${registry.count()} presets available`);
+     * ```
+     */
+    count() {
+        return this.presets.size;
+    }
+    /**
+     * Unregister a preset plugin
+     *
+     * Useful for:
+     * - Testing cleanup
+     * - Dynamic preset management
+     * - Removing deprecated presets
+     *
+     * @param key - Preset key to remove (case-insensitive)
+     * @returns true if preset was removed, false if it didn't exist
+     *
+     * @example
+     * ```typescript
+     * registry.unregister('MY_TEMPORARY_PRESET');
+     * ```
+     */
+    unregister(key) {
+        return this.presets.delete(key.toUpperCase());
+    }
+    /**
+     * Clear all registered presets
+     *
+     * ⚠️ USE WITH CAUTION: This removes ALL presets including built-ins.
+     *
+     * Useful for:
+     * - Test teardown
+     * - Complete re-initialization scenarios
+     *
+     * @example
+     * ```typescript
+     * // In test cleanup
+     * afterEach(() => {
+     *   registry.clear();
+     * });
+     * ```
+     */
+    clear() {
+        this.presets.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetRegistry, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset-registry.js","sourceRoot":"","sources":["../../../src/core/preset-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAqB,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;;AAE/E;;;;;;;;;;GAUG;AAIH,MAAM,OAAO,cAAc;IACzB;;;;OAIG;IACc,OAAO,GAAG,IAAI,GAAG,EAA6B,CAAC;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,QAAQ,CAAC,MAAyB;QAChC,kBAAkB;QAClB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,4EAA4E;gBAC5E,aAAa,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CACtC,CAAC;QACJ,CAAC;QAED,4BAA4B;QAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QAED,gCAAgC;QAChC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,yBAAyB;QAE/D,qBAAqB;QACrB,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,OAAO,CAAC,IAAI,CACV,iDAAiD,GAAG,KAAK;gBACzD,wDAAwD,CACzD,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,OAA4B;QACtC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,UAAU;QACR,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,GAAW;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;QACH,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;wGAvNU,cAAc;4GAAd,cAAc,cAFb,MAAM;;4FAEP,cAAc;kBAH1B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["/**\n * Preset Registry Service\n * \n * Version: 3.6.0\n * \n * Central registry for all date range preset plugins (built-in and custom).\n * \n * ARCHITECTURE:\n * - Singleton service (providedIn: 'root')\n * - Manages Map<string, RangePresetPlugin>\n * - Thread-safe registration\n * - Supports plugin override (useful for testing)\n * \n * USAGE:\n * ```typescript\n * // In app\n * const registry = inject(PresetRegistry);\n * \n * // Register custom preset\n * registry.register({\n *   key: 'MY_CUSTOM_PRESET',\n *   resolve: (clock, adapter) => {\n *     const now = clock.now();\n *     return { start: now, end: now };\n *   }\n * });\n * \n * // Check if preset exists\n * if (registry.has('MY_CUSTOM_PRESET')) {\n *   store.applyPreset('MY_CUSTOM_PRESET');\n * }\n * \n * // Get all registered presets\n * const allPresets = registry.getAll();\n * console.log('Available presets:', allPresets.map(p => p.key));\n * ```\n * \n * EXTERNAL PACKAGES:\n * ```typescript\n * // @acme/fiscal-presets\n * export function provideFiscalPresets() {\n *   return {\n *     provide: APP_INITIALIZER,\n *     multi: true,\n *     useFactory: (registry: PresetRegistry) => {\n *       return () => {\n *         FISCAL_PRESETS.forEach(p => registry.register(p));\n *       };\n *     },\n *     deps: [PresetRegistry]\n *   };\n * }\n * ```\n */\n\nimport { Injectable } from '@angular/core';\nimport { RangePresetPlugin, isRangePresetPlugin } from './range-preset.plugin';\n\n/**\n * Preset Registry Service\n * \n * Manages registration and retrieval of date range preset plugins.\n * \n * DESIGN:\n * - Uses Map for O(1) lookups\n * - Immutable getAll() returns copy\n * - Supports plugin override (last registration wins)\n * - Validates plugins before registration\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class PresetRegistry {\n  /**\n   * Internal map of registered presets\n   * Key: preset key (e.g., 'TODAY', 'LAST_7_DAYS')\n   * Value: RangePresetPlugin instance\n   */\n  private readonly presets = new Map<string, RangePresetPlugin>();\n\n  /**\n   * Register a date range preset plugin\n   * \n   * If a preset with the same key already exists, it will be overridden.\n   * This is useful for:\n   * - Testing (override built-in presets with mocks)\n   * - Customization (replace default behavior)\n   * - Hot-reload scenarios\n   * \n   * @param plugin - The preset plugin to register\n   * @throws Error if plugin is invalid (missing key or resolve function)\n   * \n   * @example\n   * ```typescript\n   * registry.register({\n   *   key: 'LAST_BUSINESS_WEEK',\n   *   resolve: (clock, adapter) => {\n   *     const now = clock.now();\n   *     const dayOfWeek = adapter.getDayOfWeek(now);\n   *     \n   *     // Go back to last Friday\n   *     const daysToLastFriday = dayOfWeek === 0 ? 2 : (dayOfWeek + 2) % 7;\n   *     const lastFriday = adapter.addDays(now, -daysToLastFriday);\n   *     \n   *     // Business week: Monday to Friday\n   *     const monday = adapter.addDays(lastFriday, -4);\n   *     \n   *     return { start: monday, end: lastFriday };\n   *   }\n   * });\n   * ```\n   */\n  register(plugin: RangePresetPlugin): void {\n    // Validate plugin\n    if (!isRangePresetPlugin(plugin)) {\n      throw new Error(\n        `Invalid preset plugin: must have 'key' (string) and 'resolve' (function). ` +\n        `Received: ${JSON.stringify(plugin)}`\n      );\n    }\n\n    // Validate key is not empty\n    if (!plugin.key || plugin.key.trim().length === 0) {\n      throw new Error('Preset plugin key cannot be empty');\n    }\n\n    // Register (override if exists)\n    const key = plugin.key.toUpperCase(); // Normalize to uppercase\n    \n    // Warn if overriding\n    if (this.presets.has(key)) {\n      console.warn(\n        `[PresetRegistry] Overriding existing preset: \"${key}\". ` +\n        `This is normal if you're customizing built-in presets.`\n      );\n    }\n\n    this.presets.set(key, plugin);\n  }\n\n  /**\n   * Register multiple preset plugins at once\n   * \n   * Convenience method for bulk registration.\n   * Useful when importing preset packages.\n   * \n   * @param plugins - Array of preset plugins to register\n   * \n   * @example\n   * ```typescript\n   * import { FISCAL_PRESETS } from '@acme/fiscal-presets';\n   * \n   * registry.registerAll(FISCAL_PRESETS);\n   * ```\n   */\n  registerAll(plugins: RangePresetPlugin[]): void {\n    plugins.forEach(plugin => this.register(plugin));\n  }\n\n  /**\n   * Get a preset plugin by key\n   * \n   * @param key - Preset key (case-insensitive, e.g., 'today' or 'TODAY')\n   * @returns The preset plugin or undefined if not found\n   * \n   * @example\n   * ```typescript\n   * const preset = registry.get('LAST_7_DAYS');\n   * if (preset) {\n   *   const range = preset.resolve(clock, adapter);\n   *   console.log('Range:', range);\n   * }\n   * ```\n   */\n  get(key: string): RangePresetPlugin | undefined {\n    return this.presets.get(key.toUpperCase());\n  }\n\n  /**\n   * Check if a preset exists in the registry\n   * \n   * @param key - Preset key (case-insensitive)\n   * @returns true if preset exists, false otherwise\n   * \n   * @example\n   * ```typescript\n   * if (registry.has('THIS_FISCAL_QUARTER')) {\n   *   store.applyPreset('THIS_FISCAL_QUARTER');\n   * } else {\n   *   console.error('Fiscal quarter preset not registered');\n   * }\n   * ```\n   */\n  has(key: string): boolean {\n    return this.presets.has(key.toUpperCase());\n  }\n\n  /**\n   * Get all registered preset plugins\n   * \n   * Returns a NEW array (immutable) to prevent external modification.\n   * \n   * @returns Array of all registered preset plugins\n   * \n   * @example\n   * ```typescript\n   * const allPresets = registry.getAll();\n   * console.log('Available presets:');\n   * allPresets.forEach(preset => {\n   *   console.log(`- ${preset.key}`);\n   * });\n   * ```\n   */\n  getAll(): RangePresetPlugin[] {\n    return Array.from(this.presets.values());\n  }\n\n  /**\n   * Get all preset keys\n   * \n   * Convenience method to list available preset identifiers.\n   * \n   * @returns Array of preset keys (uppercase)\n   * \n   * @example\n   * ```typescript\n   * const keys = registry.getAllKeys();\n   * // ['TODAY', 'YESTERDAY', 'LAST_7_DAYS', 'THIS_MONTH', ...]\n   * ```\n   */\n  getAllKeys(): string[] {\n    return Array.from(this.presets.keys());\n  }\n\n  /**\n   * Get count of registered presets\n   * \n   * @returns Number of registered presets\n   * \n   * @example\n   * ```typescript\n   * console.log(`${registry.count()} presets available`);\n   * ```\n   */\n  count(): number {\n    return this.presets.size;\n  }\n\n  /**\n   * Unregister a preset plugin\n   * \n   * Useful for:\n   * - Testing cleanup\n   * - Dynamic preset management\n   * - Removing deprecated presets\n   * \n   * @param key - Preset key to remove (case-insensitive)\n   * @returns true if preset was removed, false if it didn't exist\n   * \n   * @example\n   * ```typescript\n   * registry.unregister('MY_TEMPORARY_PRESET');\n   * ```\n   */\n  unregister(key: string): boolean {\n    return this.presets.delete(key.toUpperCase());\n  }\n\n  /**\n   * Clear all registered presets\n   * \n   * ⚠️ USE WITH CAUTION: This removes ALL presets including built-ins.\n   * \n   * Useful for:\n   * - Test teardown\n   * - Complete re-initialization scenarios\n   * \n   * @example\n   * ```typescript\n   * // In test cleanup\n   * afterEach(() => {\n   *   registry.clear();\n   * });\n   * ```\n   */\n  clear(): void {\n    this.presets.clear();\n  }\n}\n"]}