@oneluiz/dual-datepicker 3.5.0 → 3.5.1

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