@mapvx/web-js 4.0.3-dev.1 → 4.0.3-dev.2

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

@@ -1,24 +1,8 @@
 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)
+            const dayNumber = date.getDay();
             switch (dayNumber) {
                 case 0:
                     return "su";
@@ -35,7 +19,6 @@ export class OpeningHoursHelper {
                 case 6:
                     return "sa";
                 default:
-                    // This default shouldn't happen. I'll add it just for completeness.
                     return null;
             }
         }
@@ -43,21 +26,6 @@ export class OpeningHoursHelper {
             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 {
@@ -98,31 +66,16 @@ export class OpeningHoursHelper {
             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 "";
             }
@@ -132,21 +85,6 @@ export class OpeningHoursHelper {
             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) {
@@ -172,21 +110,6 @@ export class OpeningHoursHelper {
             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);
@@ -199,7 +122,6 @@ export class OpeningHoursHelper {
                 return date.toLocaleDateString(currentLang, { weekday: "long" });
             }
             catch (_a) {
-                // Fallback to English if the language is not valid
                 return date.toLocaleDateString("en", { weekday: "long" });
             }
         }
@@ -207,19 +129,6 @@ export class OpeningHoursHelper {
             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]) => {
@@ -232,27 +141,13 @@ export class OpeningHoursHelper {
             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
+            const now = currentDate || new Date();
+            const yesterday = new Date(now);
             OpeningHoursHelper.previousDate(yesterday);
             const yesterdayString = OpeningHoursHelper.getDay(yesterday);
             if (yesterdayString == null) {
@@ -263,7 +158,6 @@ export class OpeningHoursHelper {
                 return false;
             }
             for (const interval of intervals) {
-                // Check if it's a 24-hour schedule
                 if (is24Hours(interval)) {
                     return true;
                 }
@@ -271,14 +165,13 @@ export class OpeningHoursHelper {
                     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 true;
                     }
                 }
             }
@@ -288,18 +181,6 @@ export class OpeningHoursHelper {
             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();
@@ -307,18 +188,6 @@ export class OpeningHoursHelper {
         }
         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();
@@ -326,20 +195,6 @@ export class OpeningHoursHelper {
         }
         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") {
@@ -358,7 +213,6 @@ export class OpeningHoursHelper {
                 return false;
             }
             for (const interval of intervals) {
-                // Check if it's a 24-hour schedule
                 if (is24Hours(interval)) {
                     return true;
                 }
@@ -366,7 +220,6 @@ export class OpeningHoursHelper {
                     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) {
@@ -377,25 +230,12 @@ export class OpeningHoursHelper {
                     }
                 }
             }
-            return false; // The current time is not within any interval
+            return false;
         }
         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") {
@@ -413,47 +253,18 @@ export class OpeningHoursHelper {
             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)
+            const timeRegex = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;
             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);
@@ -465,23 +276,6 @@ export class OpeningHoursHelper {
             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) {
@@ -502,28 +296,9 @@ export class OpeningHoursHelper {
             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);
             });
         }
@@ -531,19 +306,6 @@ export class OpeningHoursHelper {
             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();
@@ -564,19 +326,6 @@ export class OpeningHoursHelper {
             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();
@@ -598,23 +347,6 @@ export class OpeningHoursHelper {
             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) ||
@@ -631,19 +363,6 @@ export class OpeningHoursHelper {
             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") {
@@ -666,21 +385,6 @@ export class OpeningHoursHelper {
             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 = {
@@ -706,21 +410,6 @@ export class OpeningHoursHelper {
             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();
@@ -736,20 +425,6 @@ export class OpeningHoursHelper {
             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") {
@@ -785,20 +460,6 @@ export class OpeningHoursHelper {
             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") {
@@ -827,20 +488,6 @@ export class OpeningHoursHelper {
             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();
@@ -854,21 +501,6 @@ export class OpeningHoursHelper {
             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") {
@@ -890,12 +522,6 @@ export class 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.
- */
 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)) {
@@ -903,7 +529,5 @@ export function is24Hours(openingTime) {
     }
     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

package/dist/es/utils/preconnect.d.ts

@@ -42,4 +42,3 @@ export declare const MAPVX_DEFAULT_PRECONNECT_HOSTS: readonly string[];
  * @group Utils
  */
 export declare function injectPreconnects(hosts: readonly string[]): string[];
-//# sourceMappingURL=preconnect.d.ts.map