@mapvx/web-js 1.0.0

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

@@ -0,0 +1,906 @@
+import { InternalMapVXSDK } from "../sdk";
+/**
+ * Helper class for opening hours.
+ */
+export 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 = parseInt(hourStr, 10);
+            const minute = parseInt(minuteStr, 10);
+            if (isNaN(hour) || 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 = InternalMapVXSDK.getLang();
+                return date.toLocaleDateString(currentLang, { weekday: "long" });
+            }
+            catch (error) {
+                // Fallback to English if the language is not valid
+                return date.toLocaleDateString("en", { weekday: "long" });
+            }
+        }
+        catch (_a) {
+            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 &&
+                    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 &&
+                    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 && intervals.length > 0);
+        }
+        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 && intervals.length > 0) {
+                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 && intervals.length > 0) {
+                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 = parseInt(hoursStr, 10);
+            const minutes = parseInt(minutesStr, 10);
+            if (isNaN(hours) || 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 && 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 = parseInt(hoursStr, 10);
+            const minutes = parseInt(minutesStr, 10);
+            if (isNaN(hours) || isNaN(minutes)) {
+                return 0;
+            }
+            return hours * 60 + minutes;
+        }
+        catch (_a) {
+            return 0;
+        }
+    }
+}
+/**
+ * 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.
+ */
+export 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