@mapvx/web-js 3.6.0-dev.1 → 4.0.0-dev.1

package/dist/cjs/utils/opening-hours-helper.js

@@ -1,914 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpeningHoursHelper = void 0;
-exports.is24Hours = is24Hours;
-const sdk_1 = require("../sdk");
-/**
- * Helper class for opening hours.
- */
-class OpeningHoursHelper {
-    /**
-     * Gets the day of the week as a two-character string indicator.
-     *
-     * @param date The Date object to extract the day from.
-     * @returns A `DaysOfTheWeek` string representing the day of the week.
-     * @example
-     * ```typescript
-     * const date = new Date(2024, 0, 1); // Monday
-     * const day = OpeningHoursHelper.getDay(date);
-     * console.log(day); // "mo"
-     * ```
-     * @default Returns null if an error occurs or invalid date is provided.
-     */
-    static getDay(date) {
-        try {
-            const dayNumber = date.getDay(); // JavaScript getDay() returns 0-6 (Sun-Sat)
-            switch (dayNumber) {
-                case 0:
-                    return "su";
-                case 1:
-                    return "mo";
-                case 2:
-                    return "tu";
-                case 3:
-                    return "we";
-                case 4:
-                    return "th";
-                case 5:
-                    return "fr";
-                case 6:
-                    return "sa";
-                default:
-                    // This default shouldn't happen. I'll add it just for completeness.
-                    return null;
-            }
-        }
-        catch (_a) {
-            return null;
-        }
-    }
-    /**
-     * Converts a 24-hour time format to 12-hour format with AM/PM.
-     *
-     * @param time24h The time string in 24-hour format (HH:mm).
-     * @returns Time formatted in 12-hour format with AM/PM.
-     * @example
-     * ```typescript
-     * const time12h = OpeningHoursHelper.convertSingleTimeTo12Hour("14:30");
-     * console.log(time12h); // "2:30 p.m."
-     *
-     * const morningTime = OpeningHoursHelper.convertSingleTimeTo12Hour("09:00");
-     * console.log(morningTime); // "9:00 a.m."
-     * ```
-     * @default Returns empty string "" if an error occurs or invalid time is provided.
-     */
-    static convertSingleTimeTo12Hour(time24h) {
-        var _a;
-        try {
-            if (!time24h || typeof time24h !== "string") {
-                return "";
-            }
-            const [hourStr, minuteStr] = (_a = time24h.split(":")) !== null && _a !== void 0 ? _a : [];
-            if (!hourStr || !minuteStr) {
-                return "";
-            }
-            const hour = Number.parseInt(hourStr, 10);
-            const minute = Number.parseInt(minuteStr, 10);
-            if (Number.isNaN(hour) ||
-                Number.isNaN(minute) ||
-                hour < 0 ||
-                hour > 23 ||
-                minute < 0 ||
-                minute > 59) {
-                return "";
-            }
-            let displayHour = hour % 24;
-            let period;
-            if (displayHour < 12) {
-                period = "a.m.";
-                if (displayHour === 0) {
-                    displayHour = 12;
-                }
-            }
-            else {
-                period = "p.m.";
-                if (displayHour !== 12) {
-                    displayHour -= 12;
-                }
-            }
-            return `${displayHour}:${minute < 10 ? "0" : ""}${minute} ${period}`;
-        }
-        catch (_b) {
-            return "";
-        }
-    }
-    /**
-     * Formats an opening time schedule into a readable string.
-     *
-     * @param openingTime The opening time object containing open and close times.
-     * @returns Formatted time schedule string.
-     * @example
-     * ```typescript
-     * const schedule = { open: "09:00", close: "17:00" };
-     * const formatted = OpeningHoursHelper.formatTimeSchedule(schedule);
-     * console.log(formatted); // "9:00 a.m. - 5:00 p.m."
-     * ```
-     * @default Returns empty string "" if an error occurs or invalid opening time is provided.
-     */
-    static formatTimeSchedule(openingTime) {
-        try {
-            if (!openingTime || !openingTime.open || !openingTime.close) {
-                return "";
-            }
-            // Check if it's a 24-hour schedule
-            if (is24Hours(openingTime)) {
-                return "24 hrs";
-            }
-            const openTime = OpeningHoursHelper.convertSingleTimeTo12Hour(openingTime.open);
-            const closeTime = OpeningHoursHelper.convertSingleTimeTo12Hour(openingTime.close);
-            // Check if conversion failed (returned empty string)
-            if (openTime === "" || closeTime === "") {
-                return "";
-            }
-            return `${openTime} - ${closeTime}`;
-        }
-        catch (_a) {
-            return "";
-        }
-    }
-    /**
-     * Gets the day number (1-7) for a given day string.
-     *
-     * @param day The two-character day string (e.g., "mo", "tu").
-     * @returns The day number (1-7), or -1 if the day is invalid.
-     * @example
-     * ```typescript
-     * const dayNumber = OpeningHoursHelper.getDayNumber("mo");
-     * console.log(dayNumber); // 1
-     *
-     * const invalidDay = OpeningHoursHelper.getDayNumber("invalid");
-     * console.log(invalidDay); // -1
-     * ```
-     * @default Returns -1 if an error occurs or invalid day string is provided.
-     */
-    static getDayNumber(day) {
-        try {
-            switch (day) {
-                case "mo":
-                    return 1;
-                case "tu":
-                    return 2;
-                case "we":
-                    return 3;
-                case "th":
-                    return 4;
-                case "fr":
-                    return 5;
-                case "sa":
-                    return 6;
-                case "su":
-                    return 7;
-                default:
-                    return -1;
-            }
-        }
-        catch (_a) {
-            return -1;
-        }
-    }
-    /**
-     * Gets the full day name (localized) for a given day string.
-     *
-     * @param day The two-character day string (e.g., "mo", "tu").
-     * @returns The localized day name, or an empty string if the day is invalid.
-     * @example
-     * ```typescript
-     * const dayName = OpeningHoursHelper.getDayName("mo");
-     * console.log(dayName); // "Monday" (or localized equivalent)
-     *
-     * const invalidDay = OpeningHoursHelper.getDayName("invalid");
-     * console.log(invalidDay); // ""
-     * ```
-     * @default Returns empty string "" if an error occurs or invalid day string is provided.
-     */
-    static getDayName(day) {
-        try {
-            const dayNumber = OpeningHoursHelper.getDayNumber(day);
-            if (dayNumber === -1) {
-                return "";
-            }
-            const date = new Date(2024, 0, dayNumber);
-            try {
-                const currentLang = sdk_1.InternalMapVXSDK.getLang();
-                return date.toLocaleDateString(currentLang, { weekday: "long" });
-            }
-            catch (_a) {
-                // Fallback to English if the language is not valid
-                return date.toLocaleDateString("en", { weekday: "long" });
-            }
-        }
-        catch (_b) {
-            return "";
-        }
-    }
-    /**
-     * Sorts the opening hours object by day of the week.
-     *
-     * @param openingHours The opening hours object to sort.
-     * @returns A new object with the opening hours sorted by day of the week.
-     * @example
-     * ```typescript
-     * const unsortedHours = { fr: [...], mo: [...], we: [...] };
-     * const sortedHours = OpeningHoursHelper.sortDays(unsortedHours);
-     * console.log(Object.keys(sortedHours)); // ["mo", "we", "fr"]
-     * ```
-     * @default Returns the original openingHours object if an error occurs.
-     */
-    static sortDays(openingHours) {
-        try {
-            return Object.fromEntries(Object.entries(openingHours).sort(([keyA], [keyB]) => {
-                const dayNumberA = OpeningHoursHelper.getDayNumber(keyA);
-                const dayNumberB = OpeningHoursHelper.getDayNumber(keyB);
-                return dayNumberA - dayNumberB;
-            }));
-        }
-        catch (_a) {
-            return openingHours;
-        }
-    }
-    /**
-     * Checks if a store is open from the previous day (for overnight hours).
-     *
-     * @param openingHours The opening hours of the store.
-     * @param currentDate Optional date to check against. If not provided, uses the current date.
-     * @returns `true` if the store is open from the previous day, `false` otherwise.
-     * @example
-     * ```typescript
-     * const overnightHours = { mo: [{ open: "22:00", close: "06:00" }] };
-     * const isOpen = OpeningHoursHelper.isOpenFromPreviousDay(overnightHours);
-     * console.log(isOpen); // true if current time is between 22:00 and 06:00
-     * ```
-     * @default Returns `false` if an error occurs or invalid opening hours are provided.
-     */
-    static isOpenFromPreviousDay(openingHours, currentDate) {
-        try {
-            if (!openingHours || typeof openingHours !== "object") {
-                return false;
-            }
-            const now = currentDate || new Date(); // Gets the current date
-            const yesterday = new Date(now); // Creates a copy of the current date
-            OpeningHoursHelper.previousDate(yesterday);
-            const yesterdayString = OpeningHoursHelper.getDay(yesterday);
-            if (yesterdayString == null) {
-                return false;
-            }
-            const intervals = openingHours[yesterdayString];
-            if (!intervals || !Array.isArray(intervals) || intervals.length === 0) {
-                return false;
-            }
-            for (const interval of intervals) {
-                // Check if it's a 24-hour schedule
-                if (is24Hours(interval)) {
-                    return true;
-                }
-                if ((interval === null || interval === void 0 ? void 0 : interval.open) &&
-                    interval.close &&
-                    OpeningHoursHelper.isValidTime(interval.open) &&
-                    OpeningHoursHelper.isValidTime(interval.close)) {
-                    // Create the date object based on yesterday
-                    const openTime = OpeningHoursHelper.parseTimeAsDate(interval.open, yesterday);
-                    const closeTime = OpeningHoursHelper.parseTimeAsDate(interval.close, yesterday);
-                    if (openTime > closeTime) {
-                        OpeningHoursHelper.nextDate(closeTime);
-                    }
-                    if (now >= openTime && now <= closeTime) {
-                        return true; // The current time is within this interval
-                    }
-                }
-            }
-            return false;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Modifies the given Date object to represent the previous day.
-     *
-     * @param date The Date object to modify. This object will be mutated.
-     * @returns This function modifies the Date object in place and does not return a value.
-     * @example
-     * ```typescript
-     * const date = new Date(2024, 0, 15); // January 15, 2024
-     * OpeningHoursHelper.previousDate(date);
-     * console.log(date.getDate()); // 14
-     * ```
-     */
-    static previousDate(date) {
-        try {
-            const day = date.getDate();
-            date.setDate(day - 1);
-        }
-        catch (_a) { }
-    }
-    /**
-     * Modifies the given Date object to represent the next day.
-     *
-     * @param date The Date object to modify. This object will be mutated.
-     * @returns This function modifies the Date object in place and does not return a value.
-     * @example
-     * ```typescript
-     * const date = new Date(2024, 0, 15); // January 15, 2024
-     * OpeningHoursHelper.nextDate(date);
-     * console.log(date.getDate()); // 16
-     * ```
-     */
-    static nextDate(date) {
-        try {
-            const day = date.getDate();
-            date.setDate(day + 1);
-        }
-        catch (_a) { }
-    }
-    /**
-     * Checks if the current time is within the opening hours defined for the current day.
-     *
-     * @param openingHours An object containing the opening hours for each day of the week.
-     * @param currentDate Optional date to check against. If not provided, uses the current date.
-     * @returns `true` if the current time is within the opening hours, `false` otherwise.
-     * @example
-     * ```typescript
-     * const hours = { mo: [{ open: "09:00", close: "17:00" }] };
-     * const isOpen = OpeningHoursHelper.isWithinOpeningHours(hours);
-     * console.log(isOpen); // true if current time is between 09:00 and 17:00 on Monday
-     * ```
-     * @default Returns `false` if an error occurs or invalid opening hours are provided.
-     */
-    static isWithinOpeningHours(openingHours, currentDate) {
-        try {
-            if (!openingHours || typeof openingHours !== "object") {
-                return false;
-            }
-            const now = currentDate || new Date();
-            const dayOfWeek = OpeningHoursHelper.getDay(now);
-            if (dayOfWeek == null) {
-                return false;
-            }
-            if (OpeningHoursHelper.isOpenFromPreviousDay(openingHours, now)) {
-                return true;
-            }
-            const intervals = openingHours[dayOfWeek];
-            if (!intervals || !Array.isArray(intervals) || intervals.length === 0) {
-                return false;
-            }
-            for (const interval of intervals) {
-                // Check if it's a 24-hour schedule
-                if (is24Hours(interval)) {
-                    return true;
-                }
-                if ((interval === null || interval === void 0 ? void 0 : interval.open) &&
-                    interval.close &&
-                    OpeningHoursHelper.isValidTime(interval.open) &&
-                    OpeningHoursHelper.isValidTime(interval.close)) {
-                    // Create Date objects based on today
-                    const openTime = OpeningHoursHelper.parseTimeAsDate(interval.open, now);
-                    const closeTime = OpeningHoursHelper.parseTimeAsDate(interval.close, now);
-                    if (openTime >= closeTime) {
-                        OpeningHoursHelper.nextDate(closeTime);
-                    }
-                    if (now >= openTime && now <= closeTime) {
-                        return true;
-                    }
-                }
-            }
-            return false; // The current time is not within any interval
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Checks if there are opening times defined for today.
-     *
-     * @param openingHours The opening hours of a store.
-     * @returns `true` if there are opening times for today, `false` otherwise.
-     * @example
-     * ```typescript
-     * const hours = { mo: [{ open: "09:00", close: "17:00" }] };
-     * const hasHours = OpeningHoursHelper.hasOpeningHoursToday(hours);
-     * console.log(hasHours); // true if today is Monday
-     * ```
-     * @default Returns `false` if an error occurs or invalid opening hours are provided.
-     */
-    static hasOpeningHoursToday(openingHours) {
-        try {
-            if (!openingHours || typeof openingHours !== "object") {
-                return false;
-            }
-            const now = new Date();
-            const day = OpeningHoursHelper.getDay(now);
-            if (day == null) {
-                return false;
-            }
-            const intervals = openingHours[day];
-            return !!(intervals === null || intervals === void 0 ? void 0 : intervals.length);
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Checks if a given string is a valid time in HH:mm format.
-     *
-     * @param time The string to validate.
-     * @returns `true` if the string is a valid time, `false` otherwise.
-     * @example
-     * ```typescript
-     * const isValid = OpeningHoursHelper.isValidTime("14:30");
-     * console.log(isValid); // true
-     *
-     * const isInvalid = OpeningHoursHelper.isValidTime("25:00");
-     * console.log(isInvalid); // false
-     * ```
-     * @default Returns `false` if an error occurs or invalid time format is provided.
-     */
-    static isValidTime(time) {
-        try {
-            if (!time || typeof time !== "string") {
-                return false;
-            }
-            const timeRegex = /^([01][0-9]|2[0-3]):[0-5][0-9]$/; // HH:mm format (requires leading zero)
-            return timeRegex.test(time);
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Parses a time string (HH:mm) and combines it with a date to create a new Date object.
-     *
-     * @param time The time string in HH:mm format (e.g., "14:30").
-     * @param date An optional Date object to combine with the time. If not provided, the current date is used.
-     * @returns A new Date object representing the combined date and time.
-     * @example
-     * ```typescript
-     * const date = new Date(2024, 0, 15);
-     * const timeDate = OpeningHoursHelper.parseTimeAsDate("14:30", date);
-     * console.log(timeDate); // Date object for January 15, 2024 at 2:30 PM
-     * ```
-     * @default Returns current date if an error occurs or invalid time is provided.
-     */
-    static parseTimeAsDate(time, date) {
-        try {
-            const [hours, minutes] = time.split(":").map(Number);
-            const baseDate = date ? new Date(date) : new Date();
-            const newDate = new Date(baseDate.getFullYear(), baseDate.getMonth(), baseDate.getDate(), hours, minutes, 0, 0);
-            return newDate;
-        }
-        catch (_a) {
-            return new Date();
-        }
-    }
-    /**
-     * Flattens an array of OpeningTime objects into a single OpeningTime object,
-     * taking the earliest open time and the latest close time.
-     *
-     * @param openingTimes The array of OpeningTime objects to flatten.
-     * @returns A single OpeningTime object representing the flattened time range.
-     * @example
-     * ```typescript
-     * const times = [
-     *   { open: "09:00", close: "12:00" },
-     *   { open: "14:00", close: "18:00" }
-     * ];
-     * const flattened = OpeningHoursHelper.flattenOpeningTimes(times);
-     * console.log(flattened); // { open: "09:00", close: "18:00" }
-     * ```
-     * @default Returns `{ open: "00:00", close: "00:00" }` if an error occurs or invalid array is provided.
-     */
-    static flattenOpeningTimes(openingTimes) {
-        try {
-            if (!openingTimes || !Array.isArray(openingTimes) || openingTimes.length === 0) {
-                return { open: "00:00", close: "00:00" };
-            }
-            OpeningHoursHelper.sortOpeningTimesByOpen(openingTimes);
-            const first = openingTimes[0];
-            const last = openingTimes[openingTimes.length - 1];
-            if (!first || !last || !first.open || !last.close) {
-                return { open: "00:00", close: "00:00" };
-            }
-            return {
-                open: first.open,
-                close: last.close,
-            };
-        }
-        catch (_a) {
-            return { open: "00:00", close: "00:00" };
-        }
-    }
-    /**
-     * Sorts a list of OpeningTime objects in place, based on the 'open' property.
-     *
-     * This method mutates the array and returns a reference to the same array.
-     *
-     * @param openingTimes The array of OpeningTime objects to sort. This array will be mutated.
-     * @returns The sorted array of OpeningTime objects (mutated in place).
-     * @example
-     * ```typescript
-     * const times = [
-     *   { open: "14:00", close: "18:00" },
-     *   { open: "09:00", close: "12:00" }
-     * ];
-     * const sorted = OpeningHoursHelper.sortOpeningTimesByOpen(times);
-     * console.log(sorted[0].open); // "09:00"
-     * ```
-     * @default Returns the original array if an error occurs.
-     */
-    static sortOpeningTimesByOpen(openingTimes) {
-        try {
-            return openingTimes.sort((a, b) => {
-                // Compare the 'open' times as strings
-                return a.open.localeCompare(b.open);
-            });
-        }
-        catch (_a) {
-            return openingTimes;
-        }
-    }
-    /**
-     * Formats the opening hours for the current day into a string representation.
-     *
-     * @param openingHours The opening hours for the store.
-     * @returns A string representing the opening hours for the current day, or an empty string if there are no opening hours for today.
-     * @example
-     * ```typescript
-     * const hours = { mo: [{ open: "09:00", close: "17:00" }] };
-     * const schedule = OpeningHoursHelper.formatCurrentDaySchedule(hours);
-     * console.log(schedule); // "9:00 a.m. - 5:00 p.m." (if today is Monday)
-     * ```
-     * @default Returns empty string "" if an error occurs or no opening hours for today.
-     */
-    static formatCurrentDaySchedule(openingHours) {
-        try {
-            const now = new Date();
-            const day = OpeningHoursHelper.getDay(now);
-            if (day == null) {
-                return "";
-            }
-            const intervals = openingHours[day];
-            if (intervals === null || intervals === void 0 ? void 0 : intervals.length) {
-                const flattenedTime = OpeningHoursHelper.flattenOpeningTimes(intervals);
-                return OpeningHoursHelper.formatTimeSchedule(flattenedTime);
-            }
-            else {
-                return "";
-            }
-        }
-        catch (_a) {
-            return "";
-        }
-    }
-    /**
-     * Formats the opening hours for the previous day into a string representation.
-     *
-     * @param openingHours The opening hours for the store.
-     * @returns A string representing the opening hours for the previous day, or an empty string if there are no opening hours for yesterday.
-     * @example
-     * ```typescript
-     * const hours = { su: [{ open: "10:00", close: "15:00" }] };
-     * const schedule = OpeningHoursHelper.formatPreviousDaySchedule(hours);
-     * console.log(schedule); // "10:00 a.m. - 3:00 p.m." (if yesterday was Sunday)
-     * ```
-     * @default Returns empty string "" if an error occurs or no opening hours for yesterday.
-     */
-    static formatPreviousDaySchedule(openingHours) {
-        try {
-            const yesterday = new Date();
-            OpeningHoursHelper.previousDate(yesterday);
-            const day = OpeningHoursHelper.getDay(yesterday);
-            if (day == null) {
-                return "";
-            }
-            const intervals = openingHours[day];
-            if (intervals === null || intervals === void 0 ? void 0 : intervals.length) {
-                const flattenedTime = OpeningHoursHelper.flattenOpeningTimes(intervals);
-                return OpeningHoursHelper.formatTimeSchedule(flattenedTime);
-            }
-            else {
-                return "";
-            }
-        }
-        catch (_a) {
-            return "";
-        }
-    }
-    /**
-     * Checks if the current time is within the specified opening hours.
-     *
-     * @param openHour The opening time in HH:mm format (e.g., "09:00").
-     * @param closeHour The closing time in HH:mm format (e.g., "18:00").
-     * @param currentHour The current time in HH:mm format (e.g., "14:30").
-     * @returns `true` if the current time is within the opening hours, `false` otherwise.
-     * @example
-     * ```typescript
-     * const isWithinHours = OpeningHoursHelper.isValidSchedule("09:00", "17:00", "14:30");
-     * console.log(isWithinHours); // true
-     *
-     * const isOutsideHours = OpeningHoursHelper.isValidSchedule("09:00", "17:00", "20:00");
-     * console.log(isOutsideHours); // false
-     * ```
-     * @default Returns `false` if an error occurs or invalid time format is provided.
-     */
-    static isValidSchedule(openHour, closeHour, currentHour) {
-        try {
-            if (!OpeningHoursHelper.isValidTime(openHour) ||
-                !OpeningHoursHelper.isValidTime(closeHour) ||
-                !OpeningHoursHelper.isValidTime(currentHour)) {
-                return false;
-            }
-            const minutesOpen = OpeningHoursHelper.toMinutes(openHour);
-            const minutesClose = OpeningHoursHelper.toMinutes(closeHour);
-            const minutesCurrent = OpeningHoursHelper.toMinutes(currentHour);
-            return minutesCurrent >= minutesOpen && minutesCurrent <= minutesClose;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Parses a time string (HH:mm) and creates a Date object for today with that time.
-     *
-     * @param time The time string in HH:mm format (e.g., "14:30").
-     * @param baseDate Optional base date to use. If not provided, uses the current date.
-     * @returns A Date object representing the date with the specified time.
-     * @example
-     * ```typescript
-     * const timeDate = OpeningHoursHelper.parseTimeToDate("14:30");
-     * console.log(timeDate); // Date object for today at 2:30 PM
-     * ```
-     * @default Returns current date if an error occurs or invalid time is provided.
-     */
-    static parseTimeToDate(time, baseDate) {
-        try {
-            if (!time || typeof time !== "string") {
-                return new Date();
-            }
-            const [hoursStr, minutesStr] = time.split(":");
-            if (!hoursStr || !minutesStr) {
-                return new Date();
-            }
-            const hours = Number.parseInt(hoursStr, 10);
-            const minutes = Number.parseInt(minutesStr, 10);
-            if (Number.isNaN(hours) || Number.isNaN(minutes)) {
-                return new Date();
-            }
-            const date = baseDate ? new Date(baseDate) : new Date();
-            date.setHours(hours, minutes, 0, 0);
-            return date;
-        }
-        catch (_a) {
-            return new Date();
-        }
-    }
-    /**
-     * Converts an array of day abbreviations to a readable day range string.
-     *
-     * @param days An array of day abbreviations (e.g., ["Mo", "Tu", "We"]).
-     * @returns A string representing the day range (e.g., "Monday - Wednesday" for consecutive days, or just "Monday" for a single day).
-     * @example
-     * ```typescript
-     * const range = OpeningHoursHelper.getDaysRange(["Mo", "Tu", "We"]);
-     * console.log(range); // "Monday - Wednesday"
-     *
-     * const singleDay = OpeningHoursHelper.getDaysRange(["Mo"]);
-     * console.log(singleDay); // "Monday"
-     * ```
-     * @default Returns empty string "" if an error occurs or empty array is provided.
-     */
-    static getDaysRange(days) {
-        try {
-            const dayMap = {
-                Mo: "Monday",
-                Tu: "Tuesday",
-                We: "Wednesday",
-                Th: "Thursday",
-                Fr: "Friday",
-                Sa: "Saturday",
-                Su: "Sunday",
-            };
-            if (days.length === 0) {
-                return "";
-            }
-            const firstDay = dayMap[days[0]] || "Invalid day";
-            const lastDay = dayMap[days[days.length - 1]] || "Invalid day";
-            if (days.length === 1) {
-                return firstDay;
-            }
-            return `${firstDay} - ${lastDay}`;
-        }
-        catch (_a) {
-            return "";
-        }
-    }
-    /**
-     * Finds the next closest time from an array of time strings relative to the current date.
-     *
-     * @param times An array of time strings in HH:mm format (e.g., ["09:00", "14:30", "18:00"]).
-     * @param currentDate The current date and time to compare against.
-     * @returns The closest upcoming time string, or empty string if no times are provided.
-     * @example
-     * ```typescript
-     * const times = ["09:00", "12:00", "18:00"];
-     * const currentTime = new Date(); // Assume it's 10:30 AM
-     * const nextTime = OpeningHoursHelper.getNextClosestTime(times, currentTime);
-     * console.log(nextTime); // "12:00"
-     * ```
-     * @default Returns empty string "" if an error occurs or no times are provided.
-     */
-    static getNextClosestTime(times, currentDate) {
-        try {
-            const nowMinutes = currentDate.getHours() * 60 + currentDate.getMinutes();
-            const timesWithDiffs = times.map((time) => {
-                const timeMinutes = OpeningHoursHelper.toMinutes(time);
-                const diff = timeMinutes - nowMinutes + (timeMinutes < nowMinutes ? 24 * 60 : 0);
-                return { time, diff };
-            });
-            timesWithDiffs.sort((a, b) => a.diff - b.diff);
-            return timesWithDiffs.length > 0 ? timesWithDiffs[0].time : "";
-        }
-        catch (_a) {
-            return "";
-        }
-    }
-    /**
-     * Checks if a place is currently open based on its opening hours.
-     *
-     * @param openingHours An object containing the opening hours for each day of the week.
-     * @param currentDate Optional date to check against. If not provided, uses the current date.
-     * @returns `true` if the place is currently open, `false` otherwise.
-     * @example
-     * ```typescript
-     * const hours = { mo: [{ open: "09:00", close: "17:00" }] };
-     * const isOpen = OpeningHoursHelper.isPlaceOpen(hours);
-     * console.log(isOpen); // true if current time is between 09:00 and 17:00 on Monday
-     * ```
-     * @default Returns `false` if an error occurs or invalid opening hours are provided.
-     */
-    static isPlaceOpen(openingHours, currentDate) {
-        try {
-            if (!openingHours || typeof openingHours !== "object") {
-                return false;
-            }
-            const date = currentDate || new Date();
-            const dayName = OpeningHoursHelper.getDay(date);
-            if (dayName == null ||
-                !openingHours[dayName] ||
-                !Array.isArray(openingHours[dayName]) ||
-                openingHours[dayName].length === 0) {
-                return false;
-            }
-            const daySchedule = openingHours[dayName][0];
-            if (!daySchedule || !daySchedule.open || !daySchedule.close) {
-                return false;
-            }
-            const startTime = daySchedule.open;
-            const endTime = daySchedule.close;
-            if (!OpeningHoursHelper.isValidTime(startTime) || !OpeningHoursHelper.isValidTime(endTime)) {
-                return false;
-            }
-            const startDate = OpeningHoursHelper.parseTimeToDate(startTime, date);
-            const endDate = OpeningHoursHelper.parseTimeToDate(endTime, date);
-            if (endDate < startDate) {
-                endDate.setDate(endDate.getDate() + 1);
-            }
-            const time = new Date(date);
-            time.setSeconds(0, 0);
-            return time >= startDate && time <= endDate;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Gets the next schedule time (opening or closing) for a place in 12-hour format.
-     *
-     * @param openingHours An object containing the opening hours for each day of the week.
-     * @param currentDate Optional date to check against. If not provided, uses the current date.
-     * @returns The next schedule time in 12-hour format (e.g., "9:00 a.m." or "6:00 p.m.").
-     * @example
-     * ```typescript
-     * const hours = { mo: [{ open: "09:00", close: "17:00" }] };
-     * const nextSchedule = OpeningHoursHelper.getNextSchedule(hours);
-     * console.log(nextSchedule); // "9:00 a.m." if closed, "5:00 p.m." if open
-     * ```
-     * @default Returns "" if an error occurs or invalid opening hours are provided.
-     */
-    static getNextSchedule(openingHours, currentDate) {
-        try {
-            if (!openingHours || typeof openingHours !== "object") {
-                return "";
-            }
-            const date = currentDate || new Date();
-            const dayName = OpeningHoursHelper.getDay(date);
-            if (dayName == null ||
-                !openingHours[dayName] ||
-                !Array.isArray(openingHours[dayName]) ||
-                openingHours[dayName].length === 0) {
-                return "";
-            }
-            const daySchedule = openingHours[dayName][0];
-            if (!daySchedule || !daySchedule.open || !daySchedule.close) {
-                return "";
-            }
-            const isOpen = OpeningHoursHelper.isPlaceOpen(openingHours, date);
-            const time = isOpen ? daySchedule.close : daySchedule.open;
-            if (!time) {
-                return "";
-            }
-            return OpeningHoursHelper.convertSingleTimeTo12Hour(time);
-        }
-        catch (_a) {
-            return "";
-        }
-    }
-    /**
-     * Checks if a specific day has a schedule defined in the opening hours.
-     *
-     * @param openingHours An object containing the opening hours for each day of the week.
-     * @param currentDate Optional date to check against. If not provided, uses the current date.
-     * @returns `true` if the day has a schedule defined, `false` otherwise.
-     * @example
-     * ```typescript
-     * const hours = { mo: [{ open: "09:00", close: "17:00" }] };
-     * const hasSchedule = OpeningHoursHelper.checkDayHasSchedule(hours);
-     * console.log(hasSchedule); // true if today is Monday
-     * ```
-     * @default Returns `false` if an error occurs or invalid opening hours are provided.
-     */
-    static checkDayHasSchedule(openingHours, currentDate) {
-        try {
-            const date = currentDate || new Date();
-            const dayName = OpeningHoursHelper.getDay(date);
-            if (dayName == null) {
-                return false;
-            }
-            return !!(openingHours === null || openingHours === void 0 ? void 0 : openingHours[dayName]);
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Converts a time string (HH:mm) to total minutes since midnight.
-     *
-     * @param time The time string in HH:mm format (e.g., "14:30").
-     * @returns The total number of minutes since midnight (e.g., 870 for "14:30").
-     * @example
-     * ```typescript
-     * const minutes = OpeningHoursHelper.toMinutes("14:30");
-     * console.log(minutes); // 870
-     *
-     * const morningMinutes = OpeningHoursHelper.toMinutes("09:00");
-     * console.log(morningMinutes); // 540
-     * ```
-     * @default Returns 0 if an error occurs or invalid time format is provided.
-     */
-    static toMinutes(time) {
-        try {
-            if (!time || typeof time !== "string") {
-                return 0;
-            }
-            const [hoursStr, minutesStr] = time.split(":");
-            if (!hoursStr || !minutesStr) {
-                return 0;
-            }
-            const hours = Number.parseInt(hoursStr, 10);
-            const minutes = Number.parseInt(minutesStr, 10);
-            if (Number.isNaN(hours) || Number.isNaN(minutes)) {
-                return 0;
-            }
-            return hours * 60 + minutes;
-        }
-        catch (_a) {
-            return 0;
-        }
-    }
-}
-exports.OpeningHoursHelper = OpeningHoursHelper;
-/**
- * Checks if an OpeningTime represents a 24-hour schedule (open all day).
- *
- * @param openingTime The OpeningTime to check.
- * @returns `true` if the schedule represents 24 hours, `false` otherwise.
- */
-function is24Hours(openingTime) {
-    var _a, _b, _c, _d;
-    if (!(openingTime === null || openingTime === void 0 ? void 0 : openingTime.open) || !(openingTime === null || openingTime === void 0 ? void 0 : openingTime.close)) {
-        return false;
-    }
-    const open = (_b = (_a = openingTime === null || openingTime === void 0 ? void 0 : openingTime.open) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "";
-    const close = (_d = (_c = openingTime === null || openingTime === void 0 ? void 0 : openingTime.close) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : "";
-    // Check if open is "00:00" and close is "24:00" or "00:00"
-    return (open === "00:00" && close === "24:00") || (open === "00:00" && close === "00:00");
-}
-//# sourceMappingURL=opening-hours-helper.js.map