@f1softinternational/f1-nepali-date-picker 1.0.0

package/esm2022/lib/models/nepali-date.model.mjs

@@ -0,0 +1,258 @@
+import { BS_CALENDAR_DATA, BS_MONTHS_EN, BS_MONTHS_NP, BS_MIN_YEAR, BS_MAX_YEAR, AD_EPOCH, BS_EPOCH, getDaysInBSMonth, toNepaliDigits, } from '../utils/bs-calendar-data';
+/**
+ * NepaliDate - Represents a date in the Bikram Sambat (BS) calendar
+ */
+export class NepaliDate {
+    constructor(year, month, day) {
+        this._year = year;
+        this._month = month;
+        this._day = day;
+    }
+    // Getters
+    get year() {
+        return this._year;
+    }
+    get month() {
+        return this._month;
+    }
+    get day() {
+        return this._day;
+    }
+    /**
+     * Create NepaliDate from current date
+     */
+    static today() {
+        return NepaliDate.fromAD(new Date());
+    }
+    /**
+     * Create NepaliDate from AD Date
+     */
+    static fromAD(adDate) {
+        // Calculate days from epoch
+        const epochTime = AD_EPOCH.getTime();
+        const targetTime = new Date(adDate.getFullYear(), adDate.getMonth(), adDate.getDate()).getTime();
+        let daysDiff = Math.floor((targetTime - epochTime) / (1000 * 60 * 60 * 24));
+        if (daysDiff < 0) {
+            throw new Error('Date is before supported range');
+        }
+        let bsYear = BS_EPOCH.year;
+        let bsMonth = BS_EPOCH.month;
+        let bsDay = BS_EPOCH.day;
+        // Add days
+        while (daysDiff > 0) {
+            const daysInMonth = getDaysInBSMonth(bsYear, bsMonth);
+            const daysRemainingInMonth = daysInMonth - bsDay;
+            if (daysDiff <= daysRemainingInMonth) {
+                bsDay += daysDiff;
+                daysDiff = 0;
+            }
+            else {
+                daysDiff -= daysRemainingInMonth + 1;
+                bsMonth++;
+                bsDay = 1;
+                if (bsMonth > 12) {
+                    bsMonth = 1;
+                    bsYear++;
+                    if (bsYear > BS_MAX_YEAR) {
+                        throw new Error(`Date exceeds supported range (max: ${BS_MAX_YEAR} BS)`);
+                    }
+                }
+            }
+        }
+        return new NepaliDate(bsYear, bsMonth, bsDay);
+    }
+    /**
+     * Convert to AD Date
+     */
+    toAD() {
+        if (!this.isValid()) {
+            throw new Error('Invalid NepaliDate');
+        }
+        let totalDays = 0;
+        // Add days for complete years
+        for (let year = BS_EPOCH.year; year < this._year; year++) {
+            const yearData = BS_CALENDAR_DATA[year];
+            if (yearData) {
+                totalDays += yearData.reduce((sum, days) => sum + days, 0);
+            }
+        }
+        // Add days for complete months in current year
+        for (let month = 1; month < this._month; month++) {
+            totalDays += getDaysInBSMonth(this._year, month);
+        }
+        // Add remaining days
+        totalDays += this._day - 1;
+        // Calculate AD date from epoch
+        const adDate = new Date(AD_EPOCH);
+        adDate.setDate(adDate.getDate() + totalDays);
+        return adDate;
+    }
+    /**
+     * Check if the date is valid
+     */
+    isValid() {
+        // Check year range
+        if (this._year < BS_MIN_YEAR || this._year > BS_MAX_YEAR) {
+            return false;
+        }
+        // Check month range
+        if (this._month < 1 || this._month > 12) {
+            return false;
+        }
+        // Check day range
+        const daysInMonth = getDaysInBSMonth(this._year, this._month);
+        if (this._day < 1 || this._day > daysInMonth) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get the day of week (0 = Sunday, 6 = Saturday)
+     */
+    getDay() {
+        return this.toAD().getDay();
+    }
+    /**
+     * Get month name in specified language
+     */
+    getMonthName(lang = 'en') {
+        return lang === 'np' ? BS_MONTHS_NP[this._month - 1] : BS_MONTHS_EN[this._month - 1];
+    }
+    /**
+     * Format date according to pattern
+     * Patterns:
+     *   YYYY - 4-digit year
+     *   YY   - 2-digit year
+     *   MM   - 2-digit month
+     *   M    - month without leading zero
+     *   DD   - 2-digit day
+     *   D    - day without leading zero
+     *   MMMM - full month name (English)
+     *   mmmm - full month name (Nepali)
+     */
+    format(pattern = 'YYYY-MM-DD', useNepaliDigits = false) {
+        let result = pattern;
+        // Replace patterns (order matters - longer patterns first)
+        result = result.replace(/YYYY/g, String(this._year).padStart(4, '0'));
+        result = result.replace(/YY/g, String(this._year).slice(-2));
+        result = result.replace(/MMMM/g, BS_MONTHS_EN[this._month - 1]);
+        result = result.replace(/mmmm/g, BS_MONTHS_NP[this._month - 1]);
+        result = result.replace(/MM/g, String(this._month).padStart(2, '0'));
+        result = result.replace(/M/g, String(this._month));
+        result = result.replace(/DD/g, String(this._day).padStart(2, '0'));
+        result = result.replace(/D/g, String(this._day));
+        if (useNepaliDigits) {
+            result = toNepaliDigits(result);
+        }
+        return result;
+    }
+    /**
+     * Create a clone of this date
+     */
+    clone() {
+        return new NepaliDate(this._year, this._month, this._day);
+    }
+    /**
+     * Compare with another NepaliDate
+     * Returns: -1 if this < other, 0 if equal, 1 if this > other
+     */
+    compareTo(other) {
+        if (this._year !== other._year) {
+            return this._year < other._year ? -1 : 1;
+        }
+        if (this._month !== other._month) {
+            return this._month < other._month ? -1 : 1;
+        }
+        if (this._day !== other._day) {
+            return this._day < other._day ? -1 : 1;
+        }
+        return 0;
+    }
+    /**
+     * Check if this date is before another
+     */
+    isBefore(other) {
+        return this.compareTo(other) < 0;
+    }
+    /**
+     * Check if this date is after another
+     */
+    isAfter(other) {
+        return this.compareTo(other) > 0;
+    }
+    /**
+     * Check if this date equals another
+     */
+    equals(other) {
+        return this.compareTo(other) === 0;
+    }
+    /**
+     * Add days to date (returns new NepaliDate)
+     */
+    addDays(days) {
+        const adDate = this.toAD();
+        adDate.setDate(adDate.getDate() + days);
+        return NepaliDate.fromAD(adDate);
+    }
+    /**
+     * Add months to date (returns new NepaliDate)
+     */
+    addMonths(months) {
+        let newYear = this._year;
+        let newMonth = this._month + months;
+        while (newMonth > 12) {
+            newMonth -= 12;
+            newYear++;
+        }
+        while (newMonth < 1) {
+            newMonth += 12;
+            newYear--;
+        }
+        // Adjust day if it exceeds days in new month
+        const daysInNewMonth = getDaysInBSMonth(newYear, newMonth);
+        const newDay = Math.min(this._day, daysInNewMonth);
+        return new NepaliDate(newYear, newMonth, newDay);
+    }
+    /**
+     * Add years to date (returns new NepaliDate)
+     */
+    addYears(years) {
+        const newYear = this._year + years;
+        const daysInNewMonth = getDaysInBSMonth(newYear, this._month);
+        const newDay = Math.min(this._day, daysInNewMonth);
+        return new NepaliDate(newYear, this._month, newDay);
+    }
+    /**
+     * Get string representation
+     */
+    toString() {
+        return this.format('YYYY-MM-DD');
+    }
+    /**
+     * Convert to plain object
+     */
+    toObject() {
+        return {
+            year: this._year,
+            month: this._month,
+            day: this._day,
+        };
+    }
+    /**
+     * Create from plain object
+     */
+    static fromObject(obj) {
+        return new NepaliDate(obj.year, obj.month, obj.day);
+    }
+    /**
+     * Parse from string (YYYY-MM-DD format)
+     */
+    static parse(dateString) {
+        const parts = dateString.split('-').map(Number);
+        if (parts.length !== 3 || parts.some(isNaN)) {
+            throw new Error('Invalid date format. Expected YYYY-MM-DD');
+        }
+        return new NepaliDate(parts[0], parts[1], parts[2]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nepali-date.model.js","sourceRoot":"","sources":["../../../../../projects/f1-nepali-date-picker/src/lib/models/nepali-date.model.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    BS_CALENDAR_DATA,\n    BS_MONTHS_EN,\n    BS_MONTHS_NP,\n    BS_MIN_YEAR,\n    BS_MAX_YEAR,\n    AD_EPOCH,\n    BS_EPOCH,\n    getDaysInBSMonth,\n    toNepaliDigits,\n} from '../utils/bs-calendar-data';\n\n/**\n * NepaliDate - Represents a date in the Bikram Sambat (BS) calendar\n */\nexport class NepaliDate {\n    private _year: number;\n    private _month: number;\n    private _day: number;\n\n    constructor(year: number, month: number, day: number) {\n        this._year = year;\n        this._month = month;\n        this._day = day;\n    }\n\n    // Getters\n    get year(): number {\n        return this._year;\n    }\n\n    get month(): number {\n        return this._month;\n    }\n\n    get day(): number {\n        return this._day;\n    }\n\n    /**\n     * Create NepaliDate from current date\n     */\n    static today(): NepaliDate {\n        return NepaliDate.fromAD(new Date());\n    }\n\n    /**\n     * Create NepaliDate from AD Date\n     */\n    static fromAD(adDate: Date): NepaliDate {\n        // Calculate days from epoch\n        const epochTime = AD_EPOCH.getTime();\n        const targetTime = new Date(adDate.getFullYear(), adDate.getMonth(), adDate.getDate()).getTime();\n        let daysDiff = Math.floor((targetTime - epochTime) / (1000 * 60 * 60 * 24));\n\n        if (daysDiff < 0) {\n            throw new Error('Date is before supported range');\n        }\n\n        let bsYear = BS_EPOCH.year;\n        let bsMonth = BS_EPOCH.month;\n        let bsDay = BS_EPOCH.day;\n\n        // Add days\n        while (daysDiff > 0) {\n            const daysInMonth = getDaysInBSMonth(bsYear, bsMonth);\n            const daysRemainingInMonth = daysInMonth - bsDay;\n\n            if (daysDiff <= daysRemainingInMonth) {\n                bsDay += daysDiff;\n                daysDiff = 0;\n            } else {\n                daysDiff -= daysRemainingInMonth + 1;\n                bsMonth++;\n                bsDay = 1;\n\n                if (bsMonth > 12) {\n                    bsMonth = 1;\n                    bsYear++;\n                    if (bsYear > BS_MAX_YEAR) {\n                        throw new Error(`Date exceeds supported range (max: ${BS_MAX_YEAR} BS)`);\n                    }\n                }\n            }\n        }\n\n        return new NepaliDate(bsYear, bsMonth, bsDay);\n    }\n\n    /**\n     * Convert to AD Date\n     */\n    toAD(): Date {\n        if (!this.isValid()) {\n            throw new Error('Invalid NepaliDate');\n        }\n\n        let totalDays = 0;\n\n        // Add days for complete years\n        for (let year = BS_EPOCH.year; year < this._year; year++) {\n            const yearData = BS_CALENDAR_DATA[year];\n            if (yearData) {\n                totalDays += yearData.reduce((sum, days) => sum + days, 0);\n            }\n        }\n\n        // Add days for complete months in current year\n        for (let month = 1; month < this._month; month++) {\n            totalDays += getDaysInBSMonth(this._year, month);\n        }\n\n        // Add remaining days\n        totalDays += this._day - 1;\n\n        // Calculate AD date from epoch\n        const adDate = new Date(AD_EPOCH);\n        adDate.setDate(adDate.getDate() + totalDays);\n\n        return adDate;\n    }\n\n    /**\n     * Check if the date is valid\n     */\n    isValid(): boolean {\n        // Check year range\n        if (this._year < BS_MIN_YEAR || this._year > BS_MAX_YEAR) {\n            return false;\n        }\n\n        // Check month range\n        if (this._month < 1 || this._month > 12) {\n            return false;\n        }\n\n        // Check day range\n        const daysInMonth = getDaysInBSMonth(this._year, this._month);\n        if (this._day < 1 || this._day > daysInMonth) {\n            return false;\n        }\n\n        return true;\n    }\n\n    /**\n     * Get the day of week (0 = Sunday, 6 = Saturday)\n     */\n    getDay(): number {\n        return this.toAD().getDay();\n    }\n\n    /**\n     * Get month name in specified language\n     */\n    getMonthName(lang: 'en' | 'np' = 'en'): string {\n        return lang === 'np' ? BS_MONTHS_NP[this._month - 1] : BS_MONTHS_EN[this._month - 1];\n    }\n\n    /**\n     * Format date according to pattern\n     * Patterns:\n     *   YYYY - 4-digit year\n     *   YY   - 2-digit year\n     *   MM   - 2-digit month\n     *   M    - month without leading zero\n     *   DD   - 2-digit day\n     *   D    - day without leading zero\n     *   MMMM - full month name (English)\n     *   mmmm - full month name (Nepali)\n     */\n    format(pattern: string = 'YYYY-MM-DD', useNepaliDigits: boolean = false): string {\n        let result = pattern;\n\n        // Replace patterns (order matters - longer patterns first)\n        result = result.replace(/YYYY/g, String(this._year).padStart(4, '0'));\n        result = result.replace(/YY/g, String(this._year).slice(-2));\n        result = result.replace(/MMMM/g, BS_MONTHS_EN[this._month - 1]);\n        result = result.replace(/mmmm/g, BS_MONTHS_NP[this._month - 1]);\n        result = result.replace(/MM/g, String(this._month).padStart(2, '0'));\n        result = result.replace(/M/g, String(this._month));\n        result = result.replace(/DD/g, String(this._day).padStart(2, '0'));\n        result = result.replace(/D/g, String(this._day));\n\n        if (useNepaliDigits) {\n            result = toNepaliDigits(result);\n        }\n\n        return result;\n    }\n\n    /**\n     * Create a clone of this date\n     */\n    clone(): NepaliDate {\n        return new NepaliDate(this._year, this._month, this._day);\n    }\n\n    /**\n     * Compare with another NepaliDate\n     * Returns: -1 if this < other, 0 if equal, 1 if this > other\n     */\n    compareTo(other: NepaliDate): number {\n        if (this._year !== other._year) {\n            return this._year < other._year ? -1 : 1;\n        }\n        if (this._month !== other._month) {\n            return this._month < other._month ? -1 : 1;\n        }\n        if (this._day !== other._day) {\n            return this._day < other._day ? -1 : 1;\n        }\n        return 0;\n    }\n\n    /**\n     * Check if this date is before another\n     */\n    isBefore(other: NepaliDate): boolean {\n        return this.compareTo(other) < 0;\n    }\n\n    /**\n     * Check if this date is after another\n     */\n    isAfter(other: NepaliDate): boolean {\n        return this.compareTo(other) > 0;\n    }\n\n    /**\n     * Check if this date equals another\n     */\n    equals(other: NepaliDate): boolean {\n        return this.compareTo(other) === 0;\n    }\n\n    /**\n     * Add days to date (returns new NepaliDate)\n     */\n    addDays(days: number): NepaliDate {\n        const adDate = this.toAD();\n        adDate.setDate(adDate.getDate() + days);\n        return NepaliDate.fromAD(adDate);\n    }\n\n    /**\n     * Add months to date (returns new NepaliDate)\n     */\n    addMonths(months: number): NepaliDate {\n        let newYear = this._year;\n        let newMonth = this._month + months;\n\n        while (newMonth > 12) {\n            newMonth -= 12;\n            newYear++;\n        }\n        while (newMonth < 1) {\n            newMonth += 12;\n            newYear--;\n        }\n\n        // Adjust day if it exceeds days in new month\n        const daysInNewMonth = getDaysInBSMonth(newYear, newMonth);\n        const newDay = Math.min(this._day, daysInNewMonth);\n\n        return new NepaliDate(newYear, newMonth, newDay);\n    }\n\n    /**\n     * Add years to date (returns new NepaliDate)\n     */\n    addYears(years: number): NepaliDate {\n        const newYear = this._year + years;\n        const daysInNewMonth = getDaysInBSMonth(newYear, this._month);\n        const newDay = Math.min(this._day, daysInNewMonth);\n        return new NepaliDate(newYear, this._month, newDay);\n    }\n\n    /**\n     * Get string representation\n     */\n    toString(): string {\n        return this.format('YYYY-MM-DD');\n    }\n\n    /**\n     * Convert to plain object\n     */\n    toObject(): { year: number; month: number; day: number } {\n        return {\n            year: this._year,\n            month: this._month,\n            day: this._day,\n        };\n    }\n\n    /**\n     * Create from plain object\n     */\n    static fromObject(obj: { year: number; month: number; day: number }): NepaliDate {\n        return new NepaliDate(obj.year, obj.month, obj.day);\n    }\n\n    /**\n     * Parse from string (YYYY-MM-DD format)\n     */\n    static parse(dateString: string): NepaliDate {\n        const parts = dateString.split('-').map(Number);\n        if (parts.length !== 3 || parts.some(isNaN)) {\n            throw new Error('Invalid date format. Expected YYYY-MM-DD');\n        }\n        return new NepaliDate(parts[0], parts[1], parts[2]);\n    }\n}\n"]}

package/esm2022/lib/services/date-converter.service.mjs

@@ -0,0 +1,155 @@
+import { Injectable } from '@angular/core';
+import { NepaliDate } from '../models/nepali-date.model';
+import { BS_CALENDAR_DATA, BS_MONTHS_EN, BS_MONTHS_NP, BS_WEEKDAYS_EN, BS_WEEKDAYS_NP, BS_MIN_YEAR, BS_MAX_YEAR, getDaysInBSMonth, getTotalDaysInBSYear, toNepaliDigits, } from '../utils/bs-calendar-data';
+import * as i0 from "@angular/core";
+/**
+ * DateConverterService - Service for BS/AD date conversions and utilities
+ */
+export class DateConverterService {
+    /**
+     * Convert AD Date to NepaliDate (BS)
+     */
+    convertToBS(adDate) {
+        return NepaliDate.fromAD(adDate);
+    }
+    /**
+     * Convert NepaliDate (BS) to AD Date
+     */
+    convertToAD(bsDate) {
+        return bsDate.toAD();
+    }
+    /**
+     * Get today's date in BS
+     */
+    getTodayBS() {
+        return NepaliDate.today();
+    }
+    /**
+     * Get number of days in a BS month
+     */
+    getDaysInMonth(year, month) {
+        return getDaysInBSMonth(year, month);
+    }
+    /**
+     * Get total days in a BS year
+     */
+    getDaysInYear(year) {
+        return getTotalDaysInBSYear(year);
+    }
+    /**
+     * Get month names
+     */
+    getMonthNames(lang = 'en') {
+        return lang === 'np' ? [...BS_MONTHS_NP] : [...BS_MONTHS_EN];
+    }
+    /**
+     * Get weekday names
+     */
+    getWeekdayNames(lang = 'en') {
+        return lang === 'np' ? [...BS_WEEKDAYS_NP] : [...BS_WEEKDAYS_EN];
+    }
+    /**
+     * Get minimum supported year
+     */
+    getMinYear() {
+        return BS_MIN_YEAR;
+    }
+    /**
+     * Get maximum supported year
+     */
+    getMaxYear() {
+        return BS_MAX_YEAR;
+    }
+    /**
+     * Validate a BS date
+     */
+    isValidDate(year, month, day) {
+        const date = new NepaliDate(year, month, day);
+        return date.isValid();
+    }
+    /**
+     * Format a NepaliDate
+     */
+    format(date, pattern = 'YYYY-MM-DD', useNepaliDigits = false) {
+        return date.format(pattern, useNepaliDigits);
+    }
+    /**
+     * Parse a date string to NepaliDate
+     */
+    parse(dateString) {
+        return NepaliDate.parse(dateString);
+    }
+    /**
+     * Convert number to Nepali digits
+     */
+    toNepaliDigits(num) {
+        return toNepaliDigits(num);
+    }
+    /**
+     * Get calendar grid for a month
+     * Returns a 2D array representing weeks (rows) and days (columns)
+     * Each cell contains the day number or null for empty cells
+     */
+    getMonthCalendarGrid(year, month) {
+        const daysInMonth = this.getDaysInMonth(year, month);
+        const firstDayOfMonth = new NepaliDate(year, month, 1);
+        const startDayOfWeek = firstDayOfMonth.getDay(); // 0 = Sunday
+        const grid = [];
+        let currentWeek = [];
+        // Fill empty cells before first day
+        for (let i = 0; i < startDayOfWeek; i++) {
+            currentWeek.push(null);
+        }
+        // Fill days
+        for (let day = 1; day <= daysInMonth; day++) {
+            currentWeek.push(day);
+            if (currentWeek.length === 7) {
+                grid.push(currentWeek);
+                currentWeek = [];
+            }
+        }
+        // Fill remaining empty cells in last week
+        if (currentWeek.length > 0) {
+            while (currentWeek.length < 7) {
+                currentWeek.push(null);
+            }
+            grid.push(currentWeek);
+        }
+        return grid;
+    }
+    /**
+     * Get years range for year selector
+     */
+    getYearRange(startYear, endYear) {
+        const start = startYear ?? BS_MIN_YEAR;
+        const end = endYear ?? BS_MAX_YEAR;
+        const years = [];
+        for (let year = start; year <= end; year++) {
+            if (BS_CALENDAR_DATA[year]) {
+                years.push(year);
+            }
+        }
+        return years;
+    }
+    /**
+     * Check if a date is within a range
+     */
+    isDateInRange(date, minDate, maxDate) {
+        if (minDate && date.isBefore(minDate)) {
+            return false;
+        }
+        if (maxDate && date.isAfter(maxDate)) {
+            return false;
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateConverterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateConverterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateConverterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-converter.service.js","sourceRoot":"","sources":["../../../../../projects/f1-nepali-date-picker/src/lib/services/date-converter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { NepaliDate } from '../models/nepali-date.model';\nimport {\n    BS_CALENDAR_DATA,\n    BS_MONTHS_EN,\n    BS_MONTHS_NP,\n    BS_WEEKDAYS_EN,\n    BS_WEEKDAYS_NP,\n    BS_MIN_YEAR,\n    BS_MAX_YEAR,\n    getDaysInBSMonth,\n    getTotalDaysInBSYear,\n    toNepaliDigits,\n} from '../utils/bs-calendar-data';\n\n/**\n * DateConverterService - Service for BS/AD date conversions and utilities\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class DateConverterService {\n    /**\n     * Convert AD Date to NepaliDate (BS)\n     */\n    convertToBS(adDate: Date): NepaliDate {\n        return NepaliDate.fromAD(adDate);\n    }\n\n    /**\n     * Convert NepaliDate (BS) to AD Date\n     */\n    convertToAD(bsDate: NepaliDate): Date {\n        return bsDate.toAD();\n    }\n\n    /**\n     * Get today's date in BS\n     */\n    getTodayBS(): NepaliDate {\n        return NepaliDate.today();\n    }\n\n    /**\n     * Get number of days in a BS month\n     */\n    getDaysInMonth(year: number, month: number): number {\n        return getDaysInBSMonth(year, month);\n    }\n\n    /**\n     * Get total days in a BS year\n     */\n    getDaysInYear(year: number): number {\n        return getTotalDaysInBSYear(year);\n    }\n\n    /**\n     * Get month names\n     */\n    getMonthNames(lang: 'en' | 'np' = 'en'): string[] {\n        return lang === 'np' ? [...BS_MONTHS_NP] : [...BS_MONTHS_EN];\n    }\n\n    /**\n     * Get weekday names\n     */\n    getWeekdayNames(lang: 'en' | 'np' = 'en'): string[] {\n        return lang === 'np' ? [...BS_WEEKDAYS_NP] : [...BS_WEEKDAYS_EN];\n    }\n\n    /**\n     * Get minimum supported year\n     */\n    getMinYear(): number {\n        return BS_MIN_YEAR;\n    }\n\n    /**\n     * Get maximum supported year\n     */\n    getMaxYear(): number {\n        return BS_MAX_YEAR;\n    }\n\n    /**\n     * Validate a BS date\n     */\n    isValidDate(year: number, month: number, day: number): boolean {\n        const date = new NepaliDate(year, month, day);\n        return date.isValid();\n    }\n\n    /**\n     * Format a NepaliDate\n     */\n    format(date: NepaliDate, pattern: string = 'YYYY-MM-DD', useNepaliDigits: boolean = false): string {\n        return date.format(pattern, useNepaliDigits);\n    }\n\n    /**\n     * Parse a date string to NepaliDate\n     */\n    parse(dateString: string): NepaliDate {\n        return NepaliDate.parse(dateString);\n    }\n\n    /**\n     * Convert number to Nepali digits\n     */\n    toNepaliDigits(num: number | string): string {\n        return toNepaliDigits(num);\n    }\n\n    /**\n     * Get calendar grid for a month\n     * Returns a 2D array representing weeks (rows) and days (columns)\n     * Each cell contains the day number or null for empty cells\n     */\n    getMonthCalendarGrid(year: number, month: number): (number | null)[][] {\n        const daysInMonth = this.getDaysInMonth(year, month);\n        const firstDayOfMonth = new NepaliDate(year, month, 1);\n        const startDayOfWeek = firstDayOfMonth.getDay(); // 0 = Sunday\n\n        const grid: (number | null)[][] = [];\n        let currentWeek: (number | null)[] = [];\n\n        // Fill empty cells before first day\n        for (let i = 0; i < startDayOfWeek; i++) {\n            currentWeek.push(null);\n        }\n\n        // Fill days\n        for (let day = 1; day <= daysInMonth; day++) {\n            currentWeek.push(day);\n\n            if (currentWeek.length === 7) {\n                grid.push(currentWeek);\n                currentWeek = [];\n            }\n        }\n\n        // Fill remaining empty cells in last week\n        if (currentWeek.length > 0) {\n            while (currentWeek.length < 7) {\n                currentWeek.push(null);\n            }\n            grid.push(currentWeek);\n        }\n\n        return grid;\n    }\n\n    /**\n     * Get years range for year selector\n     */\n    getYearRange(startYear?: number, endYear?: number): number[] {\n        const start = startYear ?? BS_MIN_YEAR;\n        const end = endYear ?? BS_MAX_YEAR;\n        const years: number[] = [];\n\n        for (let year = start; year <= end; year++) {\n            if (BS_CALENDAR_DATA[year]) {\n                years.push(year);\n            }\n        }\n\n        return years;\n    }\n\n    /**\n     * Check if a date is within a range\n     */\n    isDateInRange(date: NepaliDate, minDate?: NepaliDate, maxDate?: NepaliDate): boolean {\n        if (minDate && date.isBefore(minDate)) {\n            return false;\n        }\n        if (maxDate && date.isAfter(maxDate)) {\n            return false;\n        }\n        return true;\n    }\n}\n"]}