angular-hijri-gregorian-date-time-picker 1.5.0

package/esm2020/_interfaces/calendar-model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItbW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9oaWpyaS1ncmVnb3JpYW4tZGF0ZXBpY2tlci9zcmMvX2ludGVyZmFjZXMvY2FsZW5kYXItbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgTW9udGhJbmZvIHtcbiAgZkQ6IERheUluZm87IC8vIEZpcnN0IGRheSBvZiB0aGUgbW9udGhcbiAgbEQ6IERheUluZm87IC8vIExhc3QgZGF5IG9mIHRoZSBtb250aFxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFllYXJEYXRhIHtcbiAgW21vbnRoOiBzdHJpbmddOiBNb250aEluZm87XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YSB7XG4gIFt5ZWFyOiBzdHJpbmddOiBZZWFyRGF0YTtcbn1cblxuLy8gVGltZSB2YWx1ZSBzdHJ1Y3R1cmUgZm9yIHRpbWUgcGlja2VyXG5leHBvcnQgaW50ZXJmYWNlIFRpbWVWYWx1ZSB7XG4gIGhvdXI6IG51bWJlcjsgICAvLyAwLTIzIGZvciAyNC1ob3VyIGZvcm1hdFxuICBtaW51dGU6IG51bWJlcjsgLy8gMC01OVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIERheUluZm8ge1xuICBnRDogc3RyaW5nOyAvLyBHcmVnb3JpYW4gZGF0ZVxuICB1RDogc3RyaW5nOyAvLyBVbSBhbC1RdXJyYSBkYXRlXG4gIGROOiBzdHJpbmc7IC8vIERheSBuYW1lIHNob3J0aGFuZFxuICB1QzogbnVtYmVyOyAvLyBQbGFjZWhvbGRlciBzaW5jZSB3ZSBhcmUgbm90IHVzaW5nIGl0IGluIHRoZSBvdXRwdXRcbiAgc2VsZWN0ZWQ/OiBib29sZWFuO1xuICBkaXNhYmxlZD86IGJvb2xlYW47IC8vIE5ldzogaW5kaWNhdGVzIGlmIGRheSBpcyBkaXNhYmxlZCAob3V0IG9mIG1pbi9tYXggcmFuZ2UpXG4gIHRpbWU/OiBUaW1lVmFsdWU7ICAgLy8gTmV3OiBvcHRpb25hbCB0aW1lIGluZm9ybWF0aW9uXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVG9kYXlEYXRlIHtcbiAgZ3JlZ29yaWFuPzogc3RyaW5nO1xuICB1bW1BbFF1cmE/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIE1vbnRoRGF5cyA9IERheUluZm9bXTtcbiJdfQ==

package/esm2020/_interfaces/styles-config.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGVzLWNvbmZpZy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2hpanJpLWdyZWdvcmlhbi1kYXRlcGlja2VyL3NyYy9faW50ZXJmYWNlcy9zdHlsZXMtY29uZmlnLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIHN0eWxlc0NvbmZpZyB7XG4gIGJhY2tncm91bmRDb2xvcj86IHN0cmluZztcbiAgcHJpbWFyeUNvbG9yPzogc3RyaW5nO1xuICBzZWNvbmRhcnlDb2xvcj86IHN0cmluZztcbiAgdG9kYXlzRGF0ZUJnQ29sb3I/OiBzdHJpbmc7XG4gIHRvZGF5c0RhdGVUZXh0Q29sb3I/OiBzdHJpbmc7XG4gIGNvbmZpcm1CdG5UZXh0Q29sb3I/OiBzdHJpbmc7XG4gIGRpc2FibGVkRGF5Q29sb3I/OiBzdHJpbmc7XG4gIGRheU5hbWVDb2xvcj86IHN0cmluZztcbiAgZGF5Q29sb3I/OiBzdHJpbmc7XG4gIGZvbnRGYW1pbHk/OiBzdHJpbmc7XG4gIGJvcmRlclJhZGl1cz86IHN0cmluZztcbn1cbiJdfQ==

package/esm2020/_services/date-utilities.service.mjs

@@ -0,0 +1,375 @@
+import { Injectable } from '@angular/core';
+import * as datesDictionary from '../_data/dictionary.json';
+import * as i0 from "@angular/core";
+export class DateUtilitiesService {
+    constructor() {
+        this.calendarData = datesDictionary['default']; //prod
+        // this.calendarData = datesDictionary; //debug
+    }
+    parseDate(dateStr) {
+        if (!dateStr) {
+            return null;
+        }
+        const parts = dateStr?.split('/');
+        if (parts.length !== 3) {
+            return null;
+        }
+        const [day, month, year] = parts.map(Number);
+        if (isNaN(day) ||
+            isNaN(month) ||
+            isNaN(year) ||
+            day < 1 ||
+            day > 31 ||
+            month < 1 ||
+            month > 12 ||
+            year < 1) {
+            return null;
+        }
+        return new Date(year, month - 1, day);
+    }
+    formatDate(date) {
+        const day = String(date.getDate()).padStart(2, '0');
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const year = date.getFullYear();
+        return `${day}/${month}/${year}`;
+    }
+    getDayShortHand(date) {
+        return date.toLocaleString('en-US', { weekday: 'short' });
+    }
+    generateDates(fD, lD, uC) {
+        const startDate = this.parseDate(fD?.gD);
+        const endDate = this.parseDate(lD?.gD);
+        const daysInMonth = [];
+        let currentGregorianDate = new Date(startDate);
+        let currentUmmAlQuraDay = parseInt(fD?.uD?.split('/')[0]);
+        let currentUmmAlQuraMonth = parseInt(fD?.uD?.split('/')[1]);
+        let currentUmmAlQuraYear = parseInt(fD?.uD?.split('/')[2]);
+        let daysInCurrentUmmAlQuraMonth = uC;
+        while (currentGregorianDate <= endDate) {
+            const ummAlQuraDate = `${currentUmmAlQuraDay
+                .toString()
+                .padStart(2, '0')}/${currentUmmAlQuraMonth
+                .toString()
+                .padStart(2, '0')}/${currentUmmAlQuraYear}`;
+            daysInMonth.push({
+                gD: this.formatDate(currentGregorianDate),
+                uD: ummAlQuraDate,
+                dN: this.getDayShortHand(currentGregorianDate),
+                uC: 0,
+            });
+            currentGregorianDate.setDate(currentGregorianDate.getDate() + 1);
+            currentUmmAlQuraDay += 1;
+            if (currentUmmAlQuraDay > daysInCurrentUmmAlQuraMonth) {
+                currentUmmAlQuraDay = 1;
+                currentUmmAlQuraMonth += 1;
+                if (currentUmmAlQuraMonth > 12) {
+                    currentUmmAlQuraMonth = 1;
+                    currentUmmAlQuraYear += 1;
+                }
+                const nextMonthData = this.calendarData[currentUmmAlQuraYear.toString()]?.[currentUmmAlQuraMonth.toString()];
+                daysInCurrentUmmAlQuraMonth = nextMonthData ? nextMonthData.fD.uC : 30;
+            }
+        }
+        return daysInMonth;
+    }
+    convertDate(dateStr, isGregorian) {
+        if (!dateStr)
+            return null;
+        if (isGregorian) {
+            // Preprocess Gregorian date
+            const gregorianDate = this.parseDate(dateStr);
+            if (!gregorianDate)
+                return null;
+            const formattedDate = this.formatDate(gregorianDate);
+            for (const yearKey in this.calendarData) {
+                for (const monthKey in this.calendarData[yearKey]) {
+                    const monthData = this.calendarData[yearKey][monthKey];
+                    if (this.isDateInMonthRange(formattedDate, monthData.fD?.gD, monthData.lD?.gD)) {
+                        const daysInMonth = this.generateDates(monthData.fD, monthData.lD, monthData.fD?.uC);
+                        const dayMatch = daysInMonth.find((d) => d.gD === formattedDate);
+                        if (dayMatch)
+                            return dayMatch;
+                    }
+                }
+            }
+        }
+        else {
+            const [day, month, year] = dateStr.split('/').map(Number);
+            if (isNaN(day) || isNaN(month) || isNaN(year))
+                return null;
+            for (const yearKey in this.calendarData) {
+                for (const monthKey in this.calendarData[yearKey]) {
+                    const monthData = this.calendarData[yearKey][monthKey];
+                    if (this.isDateInMonthRange(`${day}/${month}/${year}`, monthData.fD?.uD, monthData.lD?.uD)) {
+                        const daysInMonth = this.generateDates(monthData.fD, monthData.lD, monthData.fD?.uC);
+                        const dayMatch = daysInMonth.find((d) => {
+                            const [uDay, uMonth, uYear] = d?.uD?.split('/').map(Number);
+                            return uDay === day && uMonth === month && uYear === year;
+                        });
+                        if (dayMatch)
+                            return dayMatch;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    isDateInMonthRange(dateToCheck, monthStartDate, monthEndDate) {
+        if (!monthStartDate || !monthEndDate)
+            return false;
+        const checkDate = this.parseDate(dateToCheck);
+        const startDate = this.parseDate(monthStartDate);
+        const endDate = this.parseDate(monthEndDate);
+        if (!checkDate || !startDate || !endDate)
+            return false;
+        return checkDate >= startDate && checkDate <= endDate;
+    }
+    getMonthData(inputDate, type) {
+        const [day, month, year] = inputDate?.split('/').map(Number);
+        let isGregorian;
+        if (type == 'greg') {
+            isGregorian = true;
+        }
+        else {
+            isGregorian = false;
+        }
+        if (isGregorian) {
+            return this.getGregorianMonthData(day, month, year);
+        }
+        else {
+            return this.getUmAlQurraMonthData(day, month, year);
+        }
+    }
+    getGregorianMonthData(day, month, year) {
+        const yearData = this.calendarData[year];
+        if (!yearData)
+            return null;
+        const monthData = yearData[month];
+        if (!monthData)
+            return null;
+        const monthArray = [];
+        const endDate = new Date(year, month, 0);
+        for (let d = 1; d <= endDate.getDate(); d++) {
+            const offset = d - 1;
+            monthArray.push({
+                gD: `${d.toString().padStart(2, '0')}/${month
+                    .toString()
+                    .padStart(2, '0')}/${year}`,
+                uD: this.calculateUmAlQurraDate(monthData.fD.uD, offset, monthData.fD.uC),
+                dN: this.getDayName(new Date(year, month - 1, d).getDay()),
+                uC: monthData.fD.uC,
+            });
+        }
+        return monthArray;
+    }
+    getUmAlQurraMonthData(day, month, year) {
+        for (const gregorianYear in this.calendarData) {
+            const yearData = this.calendarData[parseInt(gregorianYear)];
+            for (const monthIndex in yearData) {
+                const monthData = yearData[parseInt(monthIndex)];
+                const [fDay, fMonth, fYear] = monthData?.fD?.uD?.split('/').map(Number);
+                if (fYear === year && fMonth === month) {
+                    const totalDays = monthData.fD.uC;
+                    const monthArray = [];
+                    const umAlQurraStartDate = `01/${month
+                        .toString()
+                        .padStart(2, '0')}/${year}`;
+                    const dayDifference = fDay - 1;
+                    const startGregorianDate = this.calculateGregorianDate(monthData.fD.gD, -dayDifference);
+                    for (let i = 0; i < totalDays; i++) {
+                        const uDate = this.calculateUmAlQurraDate(umAlQurraStartDate, i, totalDays);
+                        const gDate = this.calculateGregorianDate(startGregorianDate, i);
+                        const [gDay, gMonth, gYear] = gDate?.split('/').map(Number);
+                        const dayName = this.getDayName(new Date(gYear, gMonth - 1, gDay).getDay());
+                        monthArray.push({
+                            gD: gDate,
+                            uD: uDate,
+                            dN: dayName,
+                            uC: totalDays,
+                        });
+                    }
+                    return monthArray;
+                }
+            }
+        }
+        return null;
+    }
+    calculateGregorianDate(startGDate, offset) {
+        const [day, month, year] = startGDate?.split('/').map(Number);
+        const newDate = new Date(year, month - 1, day + offset);
+        return `${newDate.getDate().toString().padStart(2, '0')}/${(newDate.getMonth() + 1)
+            .toString()
+            .padStart(2, '0')}/${newDate.getFullYear()}`;
+    }
+    calculateUmAlQurraDate(startUDate, offset, uC) {
+        const [day, month, year] = startUDate?.split('/').map(Number);
+        let newDay = day + offset;
+        let newMonth = month;
+        let newYear = year;
+        while (newDay > uC) {
+            newDay -= uC;
+            newMonth += 1;
+        }
+        while (newMonth > 12) {
+            newMonth = 1;
+            newYear += 1;
+        }
+        return `${newDay.toString().padStart(2, '0')}/${newMonth
+            .toString()
+            .padStart(2, '0')}/${newYear}`;
+    }
+    getDayName(dayIndex) {
+        const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+        return days[dayIndex];
+    }
+    /// Check date is it in past or future
+    checkPastOrFuture(inputDate, targetDate) {
+        if (inputDate) {
+            const [day, month, year] = inputDate?.split('/').map(Number);
+            const dateToCheck = new Date(year, month - 1, day);
+            const today = targetDate;
+            today.setHours(0, 0, 0, 0);
+            if (dateToCheck > today) {
+                return 'Future';
+            }
+            else if (dateToCheck < today) {
+                return 'Past';
+            }
+            else {
+                return 'Today';
+            }
+        }
+    }
+    /// Convert english numbers to arabic equivalent
+    parseEnglish(englishNum) {
+        if (!englishNum)
+            return englishNum;
+        const numStr = String(englishNum);
+        const arabicNumbers = [
+            '\u0660',
+            '\u0661',
+            '\u0662',
+            '\u0663',
+            '\u0664',
+            '\u0665',
+            '\u0666',
+            '\u0667',
+            '\u0668',
+            '\u0669',
+        ];
+        return numStr.replace(/[0-9]/g, (digit) => {
+            return arabicNumbers[Number(digit)] || digit;
+        });
+    }
+    /// Convert arabic numbers to english equivalent
+    parseArabic(arabicNum) {
+        return arabicNum.replace(/[٠١٢٣٤٥٦٧٨٩]/g, function (d) {
+            return d.charCodeAt(0) - 1632;
+        });
+    }
+    ///
+    convertDateNumerals(date, targetLang) {
+        const arabicNumbers = ['٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩'];
+        const englishNumbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+        const toArabic = (value) => value
+            .split('')
+            .map((char) => (/\d/.test(char) ? arabicNumbers[+char] : char))
+            .join('');
+        const toEnglish = (value) => value
+            .split('')
+            .map((char) => {
+            const index = arabicNumbers.indexOf(char);
+            return index > -1 ? englishNumbers[index] : char;
+        })
+            .join('');
+        if (targetLang === 'ar') {
+            const [day, month, year] = date.split('/');
+            return `${toArabic(year)}/${toArabic(month)}/${toArabic(day)}`;
+        }
+        else {
+            const [year, month, day] = date.split('/');
+            return `${toEnglish(day)}/${toEnglish(month)}/${toEnglish(year)}`;
+        }
+    }
+    /**
+     * Normalize input date to DD/MM/YYYY string format (Gregorian)
+     * Accepts Date object or DD/MM/YYYY string
+     */
+    normalizeDateToString(date) {
+        if (!date)
+            return null;
+        if (date instanceof Date) {
+            return this.formatDate(date);
+        }
+        // Already a string - validate format
+        const parsed = this.parseDate(date);
+        return parsed ? this.formatDate(parsed) : null;
+    }
+    /**
+     * Compare two dates (Gregorian format DD/MM/YYYY)
+     * Returns: -1 if date1 < date2, 0 if equal, 1 if date1 > date2
+     */
+    compareDates(date1Str, date2Str) {
+        const d1 = this.parseDate(date1Str);
+        const d2 = this.parseDate(date2Str);
+        if (!d1 || !d2)
+            return 0;
+        if (d1 < d2)
+            return -1;
+        if (d1 > d2)
+            return 1;
+        return 0;
+    }
+    /**
+     * Compare two Hijri dates (UM format DD/MM/YYYY)
+     * Converts to Gregorian for comparison
+     */
+    compareHijriDates(hijri1, hijri2) {
+        const day1 = this.convertDate(hijri1, false);
+        const day2 = this.convertDate(hijri2, false);
+        if (!day1?.gD || !day2?.gD)
+            return 0;
+        return this.compareDates(day1.gD, day2.gD);
+    }
+    /**
+     * Check if a date is within the specified range (inclusive)
+     * All dates in Gregorian DD/MM/YYYY format
+     */
+    isDateInRange(dateStr, minDateStr, maxDateStr) {
+        if (!dateStr)
+            return false;
+        // If no constraints, date is valid
+        if (!minDateStr && !maxDateStr)
+            return true;
+        // Check minimum constraint
+        if (minDateStr && this.compareDates(dateStr, minDateStr) < 0) {
+            return false;
+        }
+        // Check maximum constraint
+        if (maxDateStr && this.compareDates(dateStr, maxDateStr) > 0) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a Hijri date is within the specified range
+     * Converts to Gregorian for comparison
+     */
+    isHijriDateInRange(hijriDateStr, minDateStr, maxDateStr) {
+        if (!hijriDateStr)
+            return false;
+        const dayInfo = this.convertDate(hijriDateStr, false);
+        if (!dayInfo?.gD)
+            return false;
+        return this.isDateInRange(dayInfo.gD, minDateStr, maxDateStr);
+    }
+}
+DateUtilitiesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateUtilitiesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DateUtilitiesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateUtilitiesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateUtilitiesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-utilities.service.js","sourceRoot":"","sources":["../../../../projects/hijri-gregorian-datepicker/src/_services/date-utilities.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport * as datesDictionary from '../_data/dictionary.json';\nimport { Data, DayInfo, MonthDays } from '../_interfaces/calendar-model';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DateUtilitiesService {\n  public calendarData: Data;\n\n  constructor() {\n    this.calendarData = (datesDictionary as any)['default']; //prod\n    // this.calendarData = datesDictionary; //debug\n  }\n\n  parseDate(dateStr: string): Date | null {\n    if (!dateStr) {\n      return null;\n    }\n    const parts = dateStr?.split('/');\n    if (parts.length !== 3) {\n      return null;\n    }\n    const [day, month, year] = parts.map(Number);\n    if (\n      isNaN(day) ||\n      isNaN(month) ||\n      isNaN(year) ||\n      day < 1 ||\n      day > 31 ||\n      month < 1 ||\n      month > 12 ||\n      year < 1\n    ) {\n      return null;\n    }\n    return new Date(year, month - 1, day);\n  }\n\n  formatDate(date: Date): string {\n    const day = String(date.getDate()).padStart(2, '0');\n    const month = String(date.getMonth() + 1).padStart(2, '0');\n    const year = date.getFullYear();\n    return `${day}/${month}/${year}`;\n  }\n\n  getDayShortHand(date: Date): string {\n    return date.toLocaleString('en-US', { weekday: 'short' });\n  }\n\n  generateDates(fD: DayInfo, lD: DayInfo, uC: number): MonthDays {\n    const startDate = this.parseDate(fD?.gD);\n    const endDate = this.parseDate(lD?.gD);\n    const daysInMonth: MonthDays = [];\n    let currentGregorianDate = new Date(startDate);\n    let currentUmmAlQuraDay = parseInt(fD?.uD?.split('/')[0]);\n    let currentUmmAlQuraMonth = parseInt(fD?.uD?.split('/')[1]);\n    let currentUmmAlQuraYear = parseInt(fD?.uD?.split('/')[2]);\n    let daysInCurrentUmmAlQuraMonth = uC;\n    while (currentGregorianDate <= endDate) {\n      const ummAlQuraDate = `${currentUmmAlQuraDay\n        .toString()\n        .padStart(2, '0')}/${currentUmmAlQuraMonth\n        .toString()\n        .padStart(2, '0')}/${currentUmmAlQuraYear}`;\n      daysInMonth.push({\n        gD: this.formatDate(currentGregorianDate),\n        uD: ummAlQuraDate,\n        dN: this.getDayShortHand(currentGregorianDate),\n        uC: 0,\n      });\n      currentGregorianDate.setDate(currentGregorianDate.getDate() + 1);\n      currentUmmAlQuraDay += 1;\n      if (currentUmmAlQuraDay > daysInCurrentUmmAlQuraMonth) {\n        currentUmmAlQuraDay = 1;\n        currentUmmAlQuraMonth += 1;\n        if (currentUmmAlQuraMonth > 12) {\n          currentUmmAlQuraMonth = 1;\n          currentUmmAlQuraYear += 1;\n        }\n        const nextMonthData =\n          this.calendarData[currentUmmAlQuraYear.toString()]?.[\n            currentUmmAlQuraMonth.toString()\n          ];\n        daysInCurrentUmmAlQuraMonth = nextMonthData ? nextMonthData.fD.uC : 30;\n      }\n    }\n    return daysInMonth;\n  }\n\n  convertDate(dateStr: string, isGregorian: boolean): DayInfo | null {\n    if (!dateStr) return null;\n\n    if (isGregorian) {\n      // Preprocess Gregorian date\n      const gregorianDate = this.parseDate(dateStr);\n      if (!gregorianDate) return null;\n      const formattedDate = this.formatDate(gregorianDate);\n\n      for (const yearKey in this.calendarData) {\n        for (const monthKey in this.calendarData[yearKey]) {\n          const monthData = this.calendarData[yearKey][monthKey];\n\n          if (\n            this.isDateInMonthRange(\n              formattedDate,\n              monthData.fD?.gD,\n              monthData.lD?.gD\n            )\n          ) {\n            const daysInMonth = this.generateDates(\n              monthData.fD,\n              monthData.lD,\n              monthData.fD?.uC\n            );\n\n            const dayMatch = daysInMonth.find((d) => d.gD === formattedDate);\n            if (dayMatch) return dayMatch;\n          }\n        }\n      }\n    } else {\n      const [day, month, year] = dateStr.split('/').map(Number);\n\n      if (isNaN(day) || isNaN(month) || isNaN(year)) return null;\n\n      for (const yearKey in this.calendarData) {\n        for (const monthKey in this.calendarData[yearKey]) {\n          const monthData = this.calendarData[yearKey][monthKey];\n\n          if (\n            this.isDateInMonthRange(\n              `${day}/${month}/${year}`,\n              monthData.fD?.uD,\n              monthData.lD?.uD\n            )\n          ) {\n            const daysInMonth = this.generateDates(\n              monthData.fD,\n              monthData.lD,\n              monthData.fD?.uC\n            );\n\n            const dayMatch = daysInMonth.find((d) => {\n              const [uDay, uMonth, uYear] = d?.uD?.split('/').map(Number);\n              return uDay === day && uMonth === month && uYear === year;\n            });\n\n            if (dayMatch) return dayMatch;\n          }\n        }\n      }\n    }\n\n    return null;\n  }\n\n  private isDateInMonthRange(\n    dateToCheck: string,\n    monthStartDate: string | undefined,\n    monthEndDate: string | undefined\n  ): boolean {\n    if (!monthStartDate || !monthEndDate) return false;\n\n    const checkDate = this.parseDate(dateToCheck);\n    const startDate = this.parseDate(monthStartDate);\n    const endDate = this.parseDate(monthEndDate);\n\n    if (!checkDate || !startDate || !endDate) return false;\n\n    return checkDate >= startDate && checkDate <= endDate;\n  }\n\n  getMonthData(inputDate: string, type: string): DayInfo[] | null {\n    const [day, month, year] = inputDate?.split('/').map(Number);\n    let isGregorian: boolean;\n    if (type == 'greg') {\n      isGregorian = true;\n    } else {\n      isGregorian = false;\n    }\n    if (isGregorian) {\n      return this.getGregorianMonthData(day, month, year);\n    } else {\n      return this.getUmAlQurraMonthData(day, month, year);\n    }\n  }\n\n  getGregorianMonthData(\n    day: number,\n    month: number,\n    year: number\n  ): DayInfo[] | null {\n    const yearData = this.calendarData[year];\n    if (!yearData) return null;\n    const monthData = yearData[month];\n    if (!monthData) return null;\n    const monthArray: DayInfo[] = [];\n    const endDate = new Date(year, month, 0);\n    for (let d = 1; d <= endDate.getDate(); d++) {\n      const offset = d - 1;\n\n      monthArray.push({\n        gD: `${d.toString().padStart(2, '0')}/${month\n          .toString()\n          .padStart(2, '0')}/${year}`,\n        uD: this.calculateUmAlQurraDate(\n          monthData.fD.uD,\n          offset,\n          monthData.fD.uC\n        ),\n        dN: this.getDayName(new Date(year, month - 1, d).getDay()),\n        uC: monthData.fD.uC,\n      });\n    }\n\n    return monthArray;\n  }\n\n  getUmAlQurraMonthData(\n    day: number,\n    month: number,\n    year: number\n  ): DayInfo[] | null {\n    for (const gregorianYear in this.calendarData) {\n      const yearData = this.calendarData[parseInt(gregorianYear)];\n\n      for (const monthIndex in yearData) {\n        const monthData = yearData[parseInt(monthIndex)];\n        const [fDay, fMonth, fYear] = monthData?.fD?.uD?.split('/').map(Number);\n\n        if (fYear === year && fMonth === month) {\n          const totalDays = monthData.fD.uC;\n          const monthArray: DayInfo[] = [];\n          const umAlQurraStartDate = `01/${month\n            .toString()\n            .padStart(2, '0')}/${year}`;\n          const dayDifference = fDay - 1;\n\n          const startGregorianDate = this.calculateGregorianDate(\n            monthData.fD.gD,\n            -dayDifference\n          );\n\n          for (let i = 0; i < totalDays; i++) {\n            const uDate = this.calculateUmAlQurraDate(\n              umAlQurraStartDate,\n              i,\n              totalDays\n            );\n            const gDate = this.calculateGregorianDate(startGregorianDate, i);\n            const [gDay, gMonth, gYear] = gDate?.split('/').map(Number);\n            const dayName = this.getDayName(\n              new Date(gYear, gMonth - 1, gDay).getDay()\n            );\n\n            monthArray.push({\n              gD: gDate,\n              uD: uDate,\n              dN: dayName,\n              uC: totalDays,\n            });\n          }\n\n          return monthArray;\n        }\n      }\n    }\n\n    return null;\n  }\n\n  calculateGregorianDate(startGDate: string, offset: number): string {\n    const [day, month, year] = startGDate?.split('/').map(Number);\n    const newDate = new Date(year, month - 1, day + offset);\n\n    return `${newDate.getDate().toString().padStart(2, '0')}/${(\n      newDate.getMonth() + 1\n    )\n      .toString()\n      .padStart(2, '0')}/${newDate.getFullYear()}`;\n  }\n\n  calculateUmAlQurraDate(\n    startUDate: string,\n    offset: number,\n    uC: number\n  ): string {\n    const [day, month, year] = startUDate?.split('/').map(Number);\n\n    let newDay = day + offset;\n    let newMonth = month;\n    let newYear = year;\n\n    while (newDay > uC) {\n      newDay -= uC;\n      newMonth += 1;\n    }\n\n    while (newMonth > 12) {\n      newMonth = 1;\n      newYear += 1;\n    }\n\n    return `${newDay.toString().padStart(2, '0')}/${newMonth\n      .toString()\n      .padStart(2, '0')}/${newYear}`;\n  }\n\n  getDayName(dayIndex: number): string {\n    const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];\n    return days[dayIndex];\n  }\n\n  /// Check date is it in past or future\n  checkPastOrFuture(inputDate: any, targetDate: any) {\n    if (inputDate) {\n      const [day, month, year] = inputDate?.split('/').map(Number);\n      const dateToCheck = new Date(year, month - 1, day);\n      const today = targetDate;\n      today.setHours(0, 0, 0, 0);\n      if (dateToCheck > today) {\n        return 'Future';\n      } else if (dateToCheck < today) {\n        return 'Past';\n      } else {\n        return 'Today';\n      }\n    }\n  }\n\n  /// Convert english numbers to arabic equivalent\n  parseEnglish(englishNum: any) {\n    if (!englishNum) return englishNum;\n    const numStr = String(englishNum);\n    const arabicNumbers = [\n      '\\u0660',\n      '\\u0661',\n      '\\u0662',\n      '\\u0663',\n      '\\u0664',\n      '\\u0665',\n      '\\u0666',\n      '\\u0667',\n      '\\u0668',\n      '\\u0669',\n    ];\n    return numStr.replace(/[0-9]/g, (digit) => {\n      return arabicNumbers[Number(digit)] || digit;\n    });\n  }\n\n  /// Convert arabic numbers to english equivalent\n  parseArabic(arabicNum: any) {\n    return arabicNum.replace(/[٠١٢٣٤٥٦٧٨٩]/g, function (d: string) {\n      return d.charCodeAt(0) - 1632;\n    });\n  }\n\n  ///\n  convertDateNumerals(date: string, targetLang: 'en' | 'ar'): string {\n    const arabicNumbers = ['٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩'];\n    const englishNumbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];\n\n    const toArabic = (value: string) =>\n      value\n        .split('')\n        .map((char) => (/\\d/.test(char) ? arabicNumbers[+char] : char))\n        .join('');\n\n    const toEnglish = (value: string) =>\n      value\n        .split('')\n        .map((char) => {\n          const index = arabicNumbers.indexOf(char);\n          return index > -1 ? englishNumbers[index] : char;\n        })\n        .join('');\n\n    if (targetLang === 'ar') {\n      const [day, month, year] = date.split('/');\n      return `${toArabic(year)}/${toArabic(month)}/${toArabic(day)}`;\n    } else {\n      const [year, month, day] = date.split('/');\n      return `${toEnglish(day)}/${toEnglish(month)}/${toEnglish(year)}`;\n    }\n  }\n\n  /**\n   * Normalize input date to DD/MM/YYYY string format (Gregorian)\n   * Accepts Date object or DD/MM/YYYY string\n   */\n  normalizeDateToString(date: Date | string | undefined): string | null {\n    if (!date) return null;\n\n    if (date instanceof Date) {\n      return this.formatDate(date);\n    }\n\n    // Already a string - validate format\n    const parsed = this.parseDate(date);\n    return parsed ? this.formatDate(parsed) : null;\n  }\n\n  /**\n   * Compare two dates (Gregorian format DD/MM/YYYY)\n   * Returns: -1 if date1 < date2, 0 if equal, 1 if date1 > date2\n   */\n  compareDates(date1Str: string, date2Str: string): number {\n    const d1 = this.parseDate(date1Str);\n    const d2 = this.parseDate(date2Str);\n\n    if (!d1 || !d2) return 0;\n\n    if (d1 < d2) return -1;\n    if (d1 > d2) return 1;\n    return 0;\n  }\n\n  /**\n   * Compare two Hijri dates (UM format DD/MM/YYYY)\n   * Converts to Gregorian for comparison\n   */\n  compareHijriDates(hijri1: string, hijri2: string): number {\n    const day1 = this.convertDate(hijri1, false);\n    const day2 = this.convertDate(hijri2, false);\n\n    if (!day1?.gD || !day2?.gD) return 0;\n\n    return this.compareDates(day1.gD, day2.gD);\n  }\n\n  /**\n   * Check if a date is within the specified range (inclusive)\n   * All dates in Gregorian DD/MM/YYYY format\n   */\n  isDateInRange(\n    dateStr: string,\n    minDateStr: string | null,\n    maxDateStr: string | null\n  ): boolean {\n    if (!dateStr) return false;\n\n    // If no constraints, date is valid\n    if (!minDateStr && !maxDateStr) return true;\n\n    // Check minimum constraint\n    if (minDateStr && this.compareDates(dateStr, minDateStr) < 0) {\n      return false;\n    }\n\n    // Check maximum constraint\n    if (maxDateStr && this.compareDates(dateStr, maxDateStr) > 0) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Check if a Hijri date is within the specified range\n   * Converts to Gregorian for comparison\n   */\n  isHijriDateInRange(\n    hijriDateStr: string,\n    minDateStr: string | null,\n    maxDateStr: string | null\n  ): boolean {\n    if (!hijriDateStr) return false;\n\n    const dayInfo = this.convertDate(hijriDateStr, false);\n    if (!dayInfo?.gD) return false;\n\n    return this.isDateInRange(dayInfo.gD, minDateStr, maxDateStr);\n  }\n}\n"]}

package/esm2020/angular-hijri-gregorian-date-time-picker.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci1oaWpyaS1ncmVnb3JpYW4tZGF0ZS10aW1lLXBpY2tlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2hpanJpLWdyZWdvcmlhbi1kYXRlcGlja2VyL3NyYy9hbmd1bGFyLWhpanJpLWdyZWdvcmlhbi1kYXRlLXRpbWUtcGlja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=