@coreui/vue-pro 5.14.0 → 5.16.0

package/dist/cjs/components/calendar/utils.js

@@ -5,31 +5,421 @@
  * @param isoWeek - The ISO week string (e.g., "2023W05" or "2023w05").
  * @returns The Date object for the Monday of the specified week, or null if invalid.
  */
+/**
+ * Helper function to calculate Monday of ISO week 1 for a given year.
+ * @param year - The year to calculate for.
+ * @returns The Monday of ISO week 1.
+ */
+const getMondayOfISOWeek1 = (year) => {
+    const jan4 = new Date(year, 0, 4);
+    const jan4DayOfWeek = jan4.getDay();
+    const daysFromMonday = jan4DayOfWeek === 0 ? 6 : jan4DayOfWeek - 1; // Sunday = 6 days from Monday
+    const mondayOfWeek1 = new Date(jan4);
+    mondayOfWeek1.setDate(jan4.getDate() - daysFromMonday);
+    return mondayOfWeek1;
+};
+/**
+ * Helper function to calculate Monday of a specific ISO week.
+ * @param year - The year.
+ * @param week - The ISO week number.
+ * @returns The Monday of the specified ISO week.
+ */
+const getMondayOfISOWeek = (year, week) => {
+    const mondayOfWeek1 = getMondayOfISOWeek1(year);
+    const weekStart = new Date(mondayOfWeek1);
+    // prettier-ignore
+    weekStart.setDate(mondayOfWeek1.getDate() + ((week - 1) * 7));
+    return weekStart;
+};
+/**
+ * Helper function to convert a date to a month number for comparison.
+ * @param date - The date to convert.
+ * @returns A number representing year*12 + month for easy comparison.
+ */
+const dateToMonthNumber = (date) => {
+    // prettier-ignore
+    return (date.getFullYear() * 12) + date.getMonth();
+};
+/**
+ * Helper function to check if a value is within min/max range.
+ * @param value - The value to check.
+ * @param min - Minimum allowed value (null means no minimum).
+ * @param max - Maximum allowed value (null means no maximum).
+ * @returns True if the value is outside the range, false if within range.
+ */
+const isOutsideRange = (value, min, max) => {
+    if (min !== null && value < min) {
+        return true;
+    }
+    if (max !== null && value > max) {
+        return true;
+    }
+    return false;
+};
+/**
+ * Converts an ISO week string to a Date object representing the Monday of that week.
+ * @param isoWeek - The ISO week string (e.g., "2023W05" or "2023w05").
+ * @returns The Date object for the Monday of the specified week.
+ */
 const convertIsoWeekToDate = (isoWeek) => {
     const [year, week] = isoWeek.split(/[Ww]/);
-    const date = new Date(Number(year), 0, 4); // 4th Jan is always in week 1
-    date.setDate(date.getDate() - (date.getDay() || 7) + 1 + (Number(week) - 1) * 7);
-    return date;
+    const parsedYear = parseYearSmart(year);
+    const parsedWeek = Number.parseInt(week, 10);
+    // Create date from ISO week using helper function
+    return getMondayOfISOWeek(parsedYear, parsedWeek);
+};
+/**
+ * Parses a week string and returns a Date object for the Monday of that week.
+ * @param dateString - The week string to parse.
+ * @returns The Date object for the Monday of the week, or null if invalid.
+ */
+const parseWeekString = (dateString) => {
+    const weekPatterns = [
+        /^(\d{4})-W(\d{1,2})$/, // 2023-W05, 2023-W5
+        /^(\d{4})W(\d{1,2})$/, // 2023W05, 2023W5
+        /^(\d{4})\s+W(\d{1,2})$/, // 2023 W05, 2023 W5
+    ];
+    for (const pattern of weekPatterns) {
+        const match = dateString.trim().match(pattern);
+        if (match) {
+            const parsedYear = parseYearSmart(match[1]);
+            const parsedWeek = Number.parseInt(match[2], 10);
+            // Create date from ISO week using helper function
+            return getMondayOfISOWeek(parsedYear, parsedWeek);
+        }
+    }
+    // Fallback to existing ISO week parsing
+    return convertIsoWeekToDate(dateString);
+};
+/**
+ * Parses a month string and returns a Date object for the first day of that month.
+ * @param dateString - The month string to parse.
+ * @returns The Date object for the first day of the month, or null if invalid.
+ */
+const parseMonthString = (dateString) => {
+    const monthPatterns = [
+        /^(\d{2,4})[-/.\s](\d{1,2})$/, // 2023-12, 23-12, 2023/12, 23/12, 2023 12, etc.
+        /^(\d{1,2})[-/.\s](\d{2,4})$/, // 12-2023, 12-23, 12/2023, 12/23, 12 2023, etc.
+    ];
+    for (const pattern of monthPatterns) {
+        const match = dateString.trim().match(pattern);
+        if (match) {
+            const firstGroup = match[1];
+            const secondGroup = match[2];
+            // Determine which group is year and which is month
+            const parsedFirst = Number.parseInt(firstGroup, 10);
+            const parsedSecond = Number.parseInt(secondGroup, 10);
+            let parsedYear;
+            let parsedMonth;
+            // Determine which group is year and which is month based on several heuristics
+            if (firstGroup.length >= 3 || parsedFirst >= 100) {
+                // First group is clearly a year (3+ digits or >= 100)
+                parsedYear = parseYearSmart(firstGroup);
+                parsedMonth = parsedSecond - 1;
+            }
+            else if (secondGroup.length >= 3 || parsedSecond >= 100) {
+                // Second group is clearly a year (3+ digits or >= 100)
+                parsedYear = parseYearSmart(secondGroup);
+                parsedMonth = parsedFirst - 1;
+            }
+            else {
+                // Both groups are 1-2 digits, use context clues
+                // If second group is a valid month (1-12), treat first as year
+                if (parsedSecond >= 1 && parsedSecond <= 12 && (parsedFirst > 12 || parsedFirst < 1)) {
+                    parsedYear = parseYearSmart(firstGroup);
+                    parsedMonth = parsedSecond - 1;
+                }
+                else {
+                    // Default: treat second group as year
+                    parsedYear = parseYearSmart(secondGroup);
+                    parsedMonth = parsedFirst - 1;
+                }
+            }
+            if (parsedMonth >= 0 && parsedMonth <= 11) {
+                return new Date(parsedYear, parsedMonth, 1);
+            }
+        }
+    }
+    // For month selection, don't use fallback parsing - return null if no pattern matches
+    return null;
+};
+/**
+ * Parses a year string or number and returns a Date object for January 1st of that year.
+ * @param dateString - The year string or number to parse.
+ * @returns The Date object for January 1st of the year, or null if invalid.
+ */
+const parseYearString = (dateString) => {
+    const yearString = String(dateString);
+    const yearPattern = /^(\d{2,4})$/;
+    const match = yearString.trim().match(yearPattern);
+    if (match) {
+        const groups = { year: match[1] };
+        return createDateFromYear(groups);
+    }
+    return parseLocalDateString(yearString);
+};
+/**
+ * Helper function to generate multiple date format patterns based on locale.
+ * @param locale - The locale to use for date format patterns.
+ * @param includeTime - Whether to include time in the patterns.
+ * @returns Array of date format patterns.
+ */
+const generateDatePatterns = (locale, includeTime) => {
+    const referenceDate = new Date(2013, 11, 31, 17, 19, 22);
+    const patterns = [];
+    try {
+        // Get the standard locale format
+        const standardFormat = includeTime
+            ? referenceDate.toLocaleString(locale)
+            : referenceDate.toLocaleDateString(locale);
+        patterns.push(standardFormat);
+    }
+    catch {
+        // Fallback to default locale if invalid locale provided
+        const standardFormat = includeTime
+            ? referenceDate.toLocaleString('en-US')
+            : referenceDate.toLocaleDateString('en-US');
+        patterns.push(standardFormat);
+    }
+    // Generate common alternative formats by replacing separators
+    const separators = ['/', '-', '.', ' '];
+    const standardFormat = patterns[0];
+    // Detect the original separator
+    let originalSeparator = '/'; // default
+    if (standardFormat.includes('/')) {
+        originalSeparator = '/';
+    }
+    else if (standardFormat.includes('-')) {
+        originalSeparator = '-';
+    }
+    else if (standardFormat.includes('.')) {
+        originalSeparator = '.';
+    }
+    for (const sep of separators) {
+        if (sep !== originalSeparator) {
+            // Escape the original separator for regex if it's a special character
+            const escapedSeparator = originalSeparator.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
+            const altFormat = standardFormat.replaceAll(new RegExp(escapedSeparator, 'g'), sep);
+            patterns.push(altFormat);
+        }
+    }
+    return patterns;
+};
+/**
+ * Helper function to build regex pattern for date parsing.
+ * @param formatString - The date format string.
+ * @param includeTime - Whether to include time patterns.
+ * @returns The regex pattern string.
+ */
+const buildDateRegexPattern = (formatString, includeTime) => {
+    // First escape special regex characters
+    // eslint-disable-next-line unicorn/prefer-string-raw
+    let regexPattern = formatString.replaceAll(/[.*+?^${}()|[\\]\\]/g, '\\$&');
+    // Then replace the date/time components with regex groups
+    regexPattern = regexPattern
+        .replace('2013', String.raw `(?<year>\d{2,4})`)
+        .replace('12', String.raw `(?<month>\d{1,2})`)
+        .replace('31', String.raw `(?<day>\d{1,2})`);
+    if (includeTime) {
+        regexPattern = regexPattern
+            .replaceAll(/17|5/g, String.raw `(?<hour>\d{1,2})`)
+            .replace('19', String.raw `(?<minute>\d{1,2})`)
+            .replace('22', String.raw `(?<second>\d{1,2})`)
+            .replaceAll(/AM|PM/gi, '(?<ampm>[APap][Mm])');
+    }
+    return regexPattern;
+};
+/**
+ * Helper function to try parsing with multiple patterns.
+ * @param dateString - The date string to parse.
+ * @param patterns - Array of format patterns to try.
+ * @param includeTime - Whether time parsing is included.
+ * @returns Parsed groups or null if no match.
+ */
+const tryParseWithPatterns = (dateString, patterns, includeTime) => {
+    for (const pattern of patterns) {
+        const regexPattern = buildDateRegexPattern(pattern, includeTime);
+        const regex = new RegExp(`^${regexPattern}$`);
+        const match = dateString.trim().match(regex);
+        if (match?.groups) {
+            return match.groups;
+        }
+    }
+    return null;
+};
+/**
+ * Helper function to convert 12-hour to 24-hour format.
+ * @param hour - Hour string.
+ * @param ampm - AM/PM indicator.
+ * @returns Hour in 24-hour format.
+ */
+const convertTo24Hour = (hour, ampm) => {
+    const parsedHour = Number.parseInt(hour, 10);
+    if (!ampm) {
+        return parsedHour;
+    }
+    const isPM = ampm.toLowerCase() === 'pm';
+    if (isPM && parsedHour !== 12) {
+        return parsedHour + 12;
+    }
+    if (!isPM && parsedHour === 12) {
+        return 0;
+    }
+    return parsedHour;
+};
+/**
+ * Helper function to validate time components.
+ * @param hour - Hour value.
+ * @param minute - Minute value.
+ * @param second - Second value.
+ * @returns True if time components are valid.
+ */
+const validateTimeComponents = (hour, minute, second) => {
+    return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+};
+/**
+ * Helper function to validate date components.
+ * @param month - Month string.
+ * @param day - Day string.
+ * @returns True if date components are valid.
+ */
+const validateDateComponents = (month, day) => {
+    const parsedMonth = Number.parseInt(month, 10) - 1;
+    const parsedDay = Number.parseInt(day, 10);
+    return parsedMonth >= 0 && parsedMonth <= 11 && parsedDay >= 1 && parsedDay <= 31;
+};
+/**
+ * Helper function to create date with time.
+ * @param groups - Parsed date and time groups.
+ * @returns Date object or null if invalid.
+ */
+const createDateWithTime = (groups) => {
+    const { year, month, day, hour, minute, second, ampm } = groups;
+    const parsedYear = parseYearSmart(year);
+    const parsedMonth = Number.parseInt(month, 10) - 1;
+    const parsedDay = Number.parseInt(day, 10);
+    const parsedHour = convertTo24Hour(hour, ampm);
+    const parsedMinute = Number.parseInt(minute ?? '0', 10) || 0;
+    const parsedSecond = Number.parseInt(second ?? '0', 10) || 0;
+    if (!validateTimeComponents(parsedHour, parsedMinute, parsedSecond)) {
+        return null;
+    }
+    return new Date(parsedYear, parsedMonth, parsedDay, parsedHour, parsedMinute, parsedSecond);
+};
+/**
+ * Helper function to create date without time.
+ * @param groups - Parsed date groups.
+ * @returns Date object or null if invalid.
+ */
+const createDateOnly = (groups) => {
+    const { year, month, day } = groups;
+    if (!validateDateComponents(month, day)) {
+        return null;
+    }
+    const parsedYear = parseYearSmart(year);
+    const parsedMonth = Number.parseInt(month, 10) - 1;
+    const parsedDay = Number.parseInt(day, 10);
+    return new Date(parsedYear, parsedMonth, parsedDay);
+};
+/**
+ * Enhanced day parsing with locale-aware patterns.
+ * @param dateString - The day string to parse.
+ * @param locale - The locale to use for parsing.
+ * @param includeTime - Whether to include time parsing.
+ * @returns Date object or null if invalid.
+ */
+const parseDayString = (dateString, locale, includeTime) => {
+    const patterns = generateDatePatterns(locale, includeTime);
+    const groups = tryParseWithPatterns(dateString, patterns, includeTime);
+    if (!groups) {
+        // Check if input looks like a complete date (has separators and multiple parts)
+        // If so, use fallback parsing for formats like "2022/08/17", "2022-08-17"
+        // If not (like "1", "12"), return null
+        const trimmed = dateString.trim();
+        const hasDateSeparators = /[-/.:]/.test(trimmed);
+        const parts = trimmed.split(/[-/.\s:]+/).filter((part) => part.length > 0);
+        const hasMultipleParts = parts.length >= 2;
+        if (hasDateSeparators && hasMultipleParts) {
+            // Use fallback for complete date strings that don't match locale patterns
+            return parseLocalDateString(dateString);
+        }
+        // For incomplete input like "1" or "12", return null
+        return null;
+    }
+    // For day selection, require at least month and day to be present
+    if ('month' in groups && 'day' in groups) {
+        const { month, day } = groups;
+        if (!validateDateComponents(month, day)) {
+            return null;
+        }
+    }
+    else {
+        // If incomplete date information, return null instead of guessing
+        return null;
+    }
+    // Create and return appropriate date object
+    return includeTime
+        ? createDateWithTime(groups)
+        : createDateOnly(groups);
+};
+/**
+ * Parses a date string into a local Date object.
+ * @param dateString - The date string to parse.
+ * @returns The Date object in local timezone, or null if invalid.
+ */
+const parseLocalDateString = (dateString) => {
+    const _date = new Date(Date.parse(dateString));
+    if (!Number.isNaN(_date.getTime())) {
+        return _date;
+    }
+    return null;
 };
 /**
  * Converts a date string or Date object to a Date object based on selection type.
  * @param date - The date to convert.
  * @param selectionType - The type of selection ('day', 'week', 'month', 'year').
+ * @param locale - The locale to use for date parsing (for day parsing).
+ * @param includeTime - Whether to include time parsing (for day parsing).
  * @returns The corresponding Date object or null if invalid.
  */
-const convertToDateObject = (date, selectionType) => {
+const convertToDateObject = (date, selectionType, locale = 'en-US', includeTime = false) => {
+    if (date === null) {
+        return null;
+    }
     if (date instanceof Date) {
-        return date;
+        return Number.isNaN(date.getTime()) ? null : date;
     }
-    if (selectionType === 'week') {
-        return convertIsoWeekToDate(date);
+    const dateString = date;
+    switch (selectionType) {
+        case 'week': {
+            return parseWeekString(dateString);
+        }
+        case 'month': {
+            return parseMonthString(dateString);
+        }
+        case 'year': {
+            return parseYearString(dateString);
+        }
+        default: {
+            // Enhanced day parsing with locale support
+            return parseDayString(dateString, locale, includeTime);
+        }
     }
-    if (selectionType === 'month' || selectionType === 'year') {
-        const _date = new Date(Date.parse(date));
-        const userTimezoneOffset = _date.getTimezoneOffset() * 60_000;
-        return new Date(_date.getTime() + userTimezoneOffset);
+};
+/**
+ * Enhanced locale-aware date parsing function (replaces getLocalDateFromString).
+ * @param dateString - The date string to parse.
+ * @param locale - The locale to use for date format patterns.
+ * @param includeTime - Whether to include time parsing.
+ * @param selectionType - The selection type ('day', 'week', 'month', 'year').
+ * @returns A Date object if parsing succeeds, null if parsing fails.
+ */
+const getLocalDateFromString = (dateString, locale = 'en-US', includeTime = false, selectionType = 'day') => {
+    // Input validation
+    if (!dateString || typeof dateString !== 'string') {
+        return null;
     }
-    return new Date(Date.parse(date));
+    return convertToDateObject(dateString, selectionType, locale, includeTime);
 };
 /**
  * Creates groups from an array.
@@ -58,7 +448,8 @@ const getCalendarDate = (calendarDate, order, view) => {
         return new Date(calendarDate.getFullYear() + order, calendarDate.getMonth(), 1);
     }
     if (order !== 0 && view === 'years') {
-        return new Date(calendarDate.getFullYear() + 12 * order, calendarDate.getMonth(), 1);
+        // prettier-ignore
+        return new Date(calendarDate.getFullYear() + (12 * order), calendarDate.getMonth(), 1);
     }
     return calendarDate;
 };
@@ -197,7 +588,7 @@ const getISOWeekNumberAndYear = (date) => {
     tempDate.setDate(tempDate.getDate() + 3 - ((tempDate.getDay() + 6) % 7));
     const week1 = new Date(tempDate.getFullYear(), 0, 4);
     // Calculate full weeks to the date
-    const weekNumber = 1 + Math.round((tempDate.getTime() - week1.getTime()) / 86_400_000 / 7);
+    const weekNumber = 1 + Math.round((tempDate.getTime() - week1.getTime()) / (86_400_000 * 7));
     return { weekNumber, year: tempDate.getFullYear() };
 };
 /**
@@ -222,9 +613,15 @@ const getMonthDetails = (year, month, firstDayOfWeek) => {
         }
         if ((index + 1) % 7 === 0) {
             const { weekNumber, year } = getISOWeekNumberAndYear(day.date);
-            weeks[weeks.length - 1].week = { number: weekNumber, year };
+            const lastWeek = weeks.at(-1);
+            if (lastWeek) {
+                lastWeek.week = { number: weekNumber, year };
+            }
+        }
+        const lastWeek = weeks.at(-1);
+        if (lastWeek) {
+            lastWeek.days.push(day);
         }
-        weeks[weeks.length - 1].days.push(day);
     });
     return weeks;
 };
@@ -278,7 +675,7 @@ const isDateInRange = (date, start, end) => {
     const _date = removeTimeFromDate(date);
     const _start = start ? removeTimeFromDate(start) : null;
     const _end = end ? removeTimeFromDate(end) : null;
-    return !!(_start && _end && _start <= _date && _date <= _end);
+    return Boolean(_start && _end && _start <= _date && _date <= _end);
 };
 /**
  * Checks if a date is selected based on start and end dates.
@@ -327,23 +724,20 @@ const isDisableDateInRange = (startDate, endDate, disabledDates) => {
  * @returns True if the month is disabled, false otherwise.
  */
 const isMonthDisabled = (date, min, max, disabledDates) => {
-    const current = date.getFullYear() * 12 + date.getMonth();
-    const _min = min ? min.getFullYear() * 12 + min.getMonth() : null;
-    const _max = max ? max.getFullYear() * 12 + max.getMonth() : null;
-    if (_min && current < _min) {
-        return true;
-    }
-    if (_max && current > _max) {
+    const current = dateToMonthNumber(date);
+    const _min = min ? dateToMonthNumber(min) : null;
+    const _max = max ? dateToMonthNumber(max) : null;
+    if (isOutsideRange(current, _min, _max)) {
         return true;
     }
     if (disabledDates === undefined) {
         return false;
     }
-    const start = min ? Math.max(date.getTime(), min.getTime()) : date;
-    const end = max
+    const startTime = min ? Math.max(date.getTime(), min.getTime()) : date.getTime();
+    const endTime = max
         ? Math.min(date.getTime(), max.getTime())
-        : new Date(new Date().getFullYear(), 11, 31);
-    for (const currentDate = new Date(start); currentDate <= end; currentDate.setDate(currentDate.getDate() + 1)) {
+        : new Date(new Date().getFullYear(), 11, 31).getTime();
+    for (const currentDate = new Date(startTime); currentDate.getTime() <= endTime; currentDate.setDate(currentDate.getDate() + 1)) {
         if (!isDateDisabled(currentDate, min, max, disabledDates)) {
             return false;
         }
@@ -376,12 +770,10 @@ const isMonthSelected = (date, start, end) => {
  * @returns True if the month is within the range, false otherwise.
  */
 const isMonthInRange = (date, start, end) => {
-    const year = date.getFullYear();
-    const month = date.getMonth();
-    const _start = start ? start.getFullYear() * 12 + start.getMonth() : null;
-    const _end = end ? end.getFullYear() * 12 + end.getMonth() : null;
-    const _date = year * 12 + month;
-    return !!(_start && _end && _start <= _date && _date <= _end);
+    const _start = start ? dateToMonthNumber(start) : null;
+    const _end = end ? dateToMonthNumber(end) : null;
+    const _date = dateToMonthNumber(date);
+    return Boolean(_start && _end && _start <= _date && _date <= _end);
 };
 /**
  * Checks if two dates are the same calendar date.
@@ -421,20 +813,17 @@ const isYearDisabled = (date, min, max, disabledDates) => {
     const year = date.getFullYear();
     const minYear = min ? min.getFullYear() : null;
     const maxYear = max ? max.getFullYear() : null;
-    if (minYear && year < minYear) {
-        return true;
-    }
-    if (maxYear && year > maxYear) {
+    if (isOutsideRange(year, minYear, maxYear)) {
         return true;
     }
     if (disabledDates === undefined) {
         return false;
     }
-    const start = min ? Math.max(date.getTime(), min.getTime()) : date;
-    const end = max
+    const startTime = min ? Math.max(date.getTime(), min.getTime()) : date.getTime();
+    const endTime = max
         ? Math.min(date.getTime(), max.getTime())
-        : new Date(new Date().getFullYear(), 11, 31);
-    for (const currentDate = new Date(start); currentDate <= end; currentDate.setDate(currentDate.getDate() + 1)) {
+        : new Date(new Date().getFullYear(), 11, 31).getTime();
+    for (const currentDate = new Date(startTime); currentDate.getTime() <= endTime; currentDate.setDate(currentDate.getDate() + 1)) {
         if (!isDateDisabled(currentDate, min, max, disabledDates)) {
             return false;
         }
@@ -469,7 +858,7 @@ const isYearInRange = (date, start, end) => {
     const year = date.getFullYear();
     const _start = start ? start.getFullYear() : null;
     const _end = end ? end.getFullYear() : null;
-    return !!(_start && _end && _start <= year && year <= _end);
+    return Boolean(_start && _end && _start <= year && year <= _end);
 };
 /**
  * Removes the time component from a Date object.
@@ -499,13 +888,46 @@ const setTimeFromDate = (target, source) => {
     result.setHours(source.getHours(), source.getMinutes(), source.getSeconds(), source.getMilliseconds());
     return result;
 };
+/**
+ * Parses a year string with smart 2-digit handling.
+ * @param yearString - The year string to parse.
+ * @returns The parsed year as a number with intelligent century assignment.
+ */
+const parseYearSmart = (yearString) => {
+    let parsedYear = Number.parseInt(yearString, 10);
+    // Handle 2-digit years with intelligent century assignment
+    if (parsedYear < 100) {
+        const currentYear = new Date().getFullYear();
+        const currentCentury = Math.floor(currentYear / 100) * 100;
+        parsedYear = currentCentury + parsedYear;
+        // If the result is more than 50 years in the future, use previous century
+        // This creates a sliding window: for current year 2025, years 76-99 become 1976-1999
+        // and years 00-75 become 2000-2075
+        if (parsedYear > currentYear + 50) {
+            parsedYear -= 100;
+        }
+    }
+    return parsedYear;
+};
+/**
+ * Creates a date from year groups.
+ * @param groups - The year groups containing year string.
+ * @returns A Date object for January 1st of the year.
+ */
+const createDateFromYear = (groups) => {
+    const { year } = groups;
+    const parsedYear = parseYearSmart(year);
+    return new Date(parsedYear, 0, 1);
+};
 
 exports.convertIsoWeekToDate = convertIsoWeekToDate;
 exports.convertToDateObject = convertToDateObject;
+exports.createDateFromYear = createDateFromYear;
 exports.createGroupsInArray = createGroupsInArray;
 exports.getCalendarDate = getCalendarDate;
 exports.getDateBySelectionType = getDateBySelectionType;
 exports.getISOWeekNumberAndYear = getISOWeekNumberAndYear;
+exports.getLocalDateFromString = getLocalDateFromString;
 exports.getMonthDetails = getMonthDetails;
 exports.getMonthsNames = getMonthsNames;
 exports.getSelectableDates = getSelectableDates;
@@ -522,6 +944,7 @@ exports.isToday = isToday;
 exports.isYearDisabled = isYearDisabled;
 exports.isYearInRange = isYearInRange;
 exports.isYearSelected = isYearSelected;
+exports.parseYearSmart = parseYearSmart;
 exports.removeTimeFromDate = removeTimeFromDate;
 exports.setTimeFromDate = setTimeFromDate;
 //# sourceMappingURL=utils.js.map