@shopbite-de/storefront 1.4.0 → 1.5.0

package/test/nuxt/useDeliveryTime.test.ts

@@ -3,14 +3,110 @@ import { mockNuxtImport } from "@nuxt/test-utils/runtime";
 import { ref } from "vue";
 import { useDeliveryTime } from "~/composables/useDeliveryTime";
 
-const { mockDeliveryTime } = vi.hoisted(() => ({
-  mockDeliveryTime: { value: 45 }, // Use object to keep reference
-}));
+const { mockDeliveryTime, mockBusinessHours, mockHolidays } = vi.hoisted(
+  () => ({
+    mockDeliveryTime: { value: 45 },
+    mockBusinessHours: {
+      value: [
+        { dayOfWeek: 1, openingTime: "11:30", closingTime: "14:30" },
+        { dayOfWeek: 1, openingTime: "17:30", closingTime: "23:00" },
+        { dayOfWeek: 3, openingTime: "11:30", closingTime: "14:30" },
+        { dayOfWeek: 3, openingTime: "17:30", closingTime: "23:00" },
+        { dayOfWeek: 4, openingTime: "11:30", closingTime: "14:30" },
+        { dayOfWeek: 4, openingTime: "17:30", closingTime: "23:00" },
+        { dayOfWeek: 5, openingTime: "11:30", closingTime: "14:30" },
+        { dayOfWeek: 5, openingTime: "17:30", closingTime: "23:00" },
+        { dayOfWeek: 6, openingTime: "17:30", closingTime: "23:30" },
+        { dayOfWeek: 0, openingTime: "11:30", closingTime: "14:30" },
+        { dayOfWeek: 0, openingTime: "17:30", closingTime: "23:00" },
+      ],
+    },
+    mockHolidays: { value: [] },
+  }),
+);
 
 mockNuxtImport("useShopBiteConfig", () => () => ({
   deliveryTime: mockDeliveryTime,
 }));
 
+mockNuxtImport("useBusinessHours", () => () => ({
+  businessHours: mockBusinessHours,
+  getServiceIntervals: (date: Date) => {
+    const dayOfWeek = date.getDay();
+    return mockBusinessHours.value
+      .filter((bh) => bh.dayOfWeek === dayOfWeek)
+      .map((bh) => {
+        const [startH, startM] = bh.openingTime.split(":").map(Number);
+        const [endH, endM] = bh.closingTime.split(":").map(Number);
+        const start = new Date(date);
+        start.setHours(startH, startM, 0, 0);
+        const end = new Date(date);
+        end.setHours(endH, endM, 0, 0);
+        return { start, end };
+      });
+  },
+  getEarliestSelectableTime: (
+    currentTime: Date,
+    currentDeliveryTime: number | null,
+  ) => {
+    const earliest = new Date(currentTime);
+    earliest.setMinutes(earliest.getMinutes() + (currentDeliveryTime ?? 30));
+    earliest.setSeconds(0, 0);
+    return earliest;
+  },
+  findActiveInterval: (
+    currentTime: Date,
+    currentDeliveryTime: number | null,
+  ) => {
+    const intervals = [
+      { dayOfWeek: 1, openingTime: "11:30", closingTime: "14:30" },
+      { dayOfWeek: 1, openingTime: "17:30", closingTime: "23:00" },
+      { dayOfWeek: 3, openingTime: "11:30", closingTime: "14:30" },
+      { dayOfWeek: 3, openingTime: "17:30", closingTime: "23:00" },
+      { dayOfWeek: 4, openingTime: "11:30", closingTime: "14:30" },
+      { dayOfWeek: 4, openingTime: "17:30", closingTime: "23:00" },
+      { dayOfWeek: 5, openingTime: "11:30", closingTime: "14:30" },
+      { dayOfWeek: 5, openingTime: "17:30", closingTime: "23:00" },
+      { dayOfWeek: 6, openingTime: "17:30", closingTime: "23:30" },
+      { dayOfWeek: 0, openingTime: "11:30", closingTime: "14:30" },
+      { dayOfWeek: 0, openingTime: "17:30", closingTime: "23:00" },
+    ]
+      .filter((bh) => bh.dayOfWeek === currentTime.getDay())
+      .map((bh) => {
+        const [startH, startM] = bh.openingTime.split(":").map(Number);
+        const [endH, endM] = bh.closingTime.split(":").map(Number);
+        const start = new Date(currentTime);
+        start.setHours(startH, startM, 0, 0);
+        const end = new Date(currentTime);
+        end.setHours(endH, endM, 0, 0);
+        return { start, end };
+      });
+
+    const earliest = new Date(currentTime);
+    earliest.setMinutes(earliest.getMinutes() + (currentDeliveryTime ?? 30));
+    earliest.setSeconds(0, 0);
+
+    if (intervals.length === 0) return null;
+    const current = intervals.find(
+      (i) => earliest >= i.start && earliest <= i.end,
+    );
+    if (current) return current;
+    return intervals.find((i) => i.start > earliest) ?? null;
+  },
+}));
+
+mockNuxtImport("useHolidays", () => () => ({
+  isClosedHoliday: (date: Date) => {
+    if (!mockHolidays.value) return undefined;
+    const formattedDate = date.toISOString().split("T")[0];
+    return mockHolidays.value.some((h: any) => {
+      const start = h.start.split("T")[0];
+      const end = h.end.split("T")[0];
+      return formattedDate >= start && formattedDate <= end;
+    });
+  },
+}));
+
 describe("useDeliveryTime", () => {
   const now = ref(new Date("2023-10-27T12:00:00")); // A Friday
 
@@ -42,7 +138,9 @@ describe("useDeliveryTime", () => {
 
   it("should return error for invalid format", () => {
     const { validate } = useDeliveryTime(now);
-    expect(validate("invalid")).toBe("Bitte eine gültige Uhrzeit im Format HH:MM eingeben.");
+    expect(validate("invalid")).toBe(
+      "Bitte eine gültige Uhrzeit im Format HH:MM eingeben.",
+    );
   });
 
   it("should return error for time before minTime", () => {
@@ -52,10 +150,22 @@ describe("useDeliveryTime", () => {
       const [hours, mins] = minTime.value.split(":").map(Number);
       const earlyTime = new Date(now.value);
       earlyTime.setHours(hours as number);
-      earlyTime.setMinutes(mins as number - 5);
-      const earlyTimeStr = earlyTime.getHours().toString().padStart(2, '0') + ":" + earlyTime.getMinutes().toString().padStart(2, '0');
-      
-      expect(validate(earlyTimeStr)).toContain("vor dem frühestmöglichen Zeitpunkt");
+      earlyTime.setMinutes((mins as number) - 5);
+      const earlyTimeStr =
+        earlyTime.getHours().toString().padStart(2, "0") +
+        ":" +
+        earlyTime.getMinutes().toString().padStart(2, "0");
+
+      expect(validate(earlyTimeStr)).toContain(
+        "vor dem frühestmöglichen Zeitpunkt",
+      );
     }
   });
+
+  it("should return loading message when holidays are not loaded", () => {
+    mockHolidays.value = null;
+    const { helperText } = useDeliveryTime(now);
+    expect(helperText.value).toBe("Lade Informationen...");
+    mockHolidays.value = []; // Reset for other tests
+  });
 });

package/test/nuxt/useProductConfigurator.test.ts

@@ -1,12 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { useProductConfigurator } from "../../app/composables/useProductConfigurator";
 
-
-const {
-  mockInvoke,
-  mockConfigurator,
-  mockProduct,
-} = vi.hoisted(() => ({
+const { mockInvoke, mockConfigurator, mockProduct } = vi.hoisted(() => ({
   mockInvoke: vi.fn(),
   mockConfigurator: { value: [] },
   mockProduct: { value: { id: "p1", optionIds: [], options: [] } },
@@ -35,7 +30,7 @@ describe("useProductConfigurator", () => {
     mockProduct.value = {
       id: "p1",
       optionIds: [],
-      options: []
+      options: [],
     } as any;
   });
 
@@ -44,14 +39,14 @@ describe("useProductConfigurator", () => {
       {
         id: "g1",
         name: "Size",
-        options: [{ id: "o1", name: "Small" }]
-      }
+        options: [{ id: "o1", name: "Small" }],
+      },
     ] as any;
     mockProduct.value = {
       id: "p1-v1",
       parentId: "p1",
       optionIds: ["o1"],
-      options: [{ id: "o1" }]
+      options: [{ id: "o1" }],
     } as any;
 
     const { isLoadingOptions } = useProductConfigurator();
@@ -62,23 +57,26 @@ describe("useProductConfigurator", () => {
     mockProduct.value = { parentId: "parent-1" } as any;
     mockInvoke.mockResolvedValue({
       data: {
-        elements: [{ id: "variant-1" }]
-      }
+        elements: [{ id: "variant-1" }],
+      },
     });
 
     const { findVariantForSelectedOptions } = useProductConfigurator();
-    const result = await findVariantForSelectedOptions({ "Size": "o1" });
+    const result = await findVariantForSelectedOptions({ Size: "o1" });
 
-    expect(mockInvoke).toHaveBeenCalledWith("readProduct post /product", expect.any(Object));
+    expect(mockInvoke).toHaveBeenCalledWith(
+      "readProduct post /product",
+      expect.any(Object),
+    );
     expect(result).toEqual({ id: "variant-1" });
   });
 
   it("should return undefined on error in findVariantForSelectedOptions", async () => {
     mockInvoke.mockRejectedValue(new Error("API Error"));
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
 
     const { findVariantForSelectedOptions } = useProductConfigurator();
-    const result = await findVariantForSelectedOptions({ "Size": "o1" });
+    const result = await findVariantForSelectedOptions({ Size: "o1" });
 
     expect(result).toBeUndefined();
     expect(consoleSpy).toHaveBeenCalled();

package/test/nuxt/useProductVariants.test.ts

@@ -18,10 +18,10 @@ describe("useProductVariants", () => {
           group: {
             id: "group-size",
             name: "Size",
-            translated: { name: "Größe" }
+            translated: { name: "Größe" },
           },
-          translated: { name: "Klein" }
-        }
+          translated: { name: "Klein" },
+        },
       },
       {
         option: {
@@ -30,10 +30,10 @@ describe("useProductVariants", () => {
           group: {
             id: "group-size",
             name: "Size",
-            translated: { name: "Größe" }
+            translated: { name: "Größe" },
           },
-          translated: { name: "Groß" }
-        }
+          translated: { name: "Groß" },
+        },
       },
       {
         option: {
@@ -42,22 +42,22 @@ describe("useProductVariants", () => {
           group: {
             id: "group-color",
             name: "Color",
-            translated: { name: "Farbe" }
+            translated: { name: "Farbe" },
           },
-          translated: { name: "Rot" }
-        }
-      }
+          translated: { name: "Rot" },
+        },
+      },
     ]);
 
     const { variants } = useProductVariants(settings as any);
-    
+
     expect(variants.value["group-size"]).toBeDefined();
     expect(variants.value["group-size"].name).toBe("Größe");
     expect(variants.value["group-size"].options).toHaveLength(2);
     expect(variants.value["group-size"].options[0]).toEqual({
       label: "Klein",
       value: "opt-1",
-      productId: "opt-1"
+      productId: "opt-1",
     });
 
     expect(variants.value["group-color"]).toBeDefined();
@@ -71,16 +71,16 @@ describe("useProductVariants", () => {
         option: {
           id: "opt-1",
           name: "Small",
-          group: { id: "group-size", name: "Size" }
-        }
+          group: { id: "group-size", name: "Size" },
+        },
       },
       {
         option: {
           id: "opt-1",
           name: "Small",
-          group: { id: "group-size", name: "Size" }
-        }
-      }
+          group: { id: "group-size", name: "Size" },
+        },
+      },
     ]);
 
     const { variants } = useProductVariants(settings as any);

package/test/nuxt/useProductVariantsZwei.test.ts

@@ -17,13 +17,13 @@ describe("useProductVariantsZwei", () => {
         translated: { name: "Größe" },
         options: [
           { id: "opt-1", name: "Small", translated: { name: "Klein" } },
-          { id: "opt-2", name: "Large", translated: { name: "Groß" } }
-        ]
-      }
+          { id: "opt-2", name: "Large", translated: { name: "Groß" } },
+        ],
+      },
     ]);
 
     const { variants } = useProductVariantsZwei(settings);
-    
+
     expect(variants.value["group-size"]).toBeDefined();
     expect(variants.value["group-size"]?.name).toBe("Größe");
     expect(variants.value["group-size"]?.options).toHaveLength(2);
@@ -37,9 +37,9 @@ describe("useProductVariantsZwei", () => {
         name: "Size",
         options: [
           { id: "opt-1", name: "Small" },
-          { id: "opt-1", name: "Small" }
-        ]
-      }
+          { id: "opt-1", name: "Small" },
+        ],
+      },
     ]);
 
     const { variants } = useProductVariantsZwei(settings);

package/test/nuxt/useScrollAnimation.test.ts

@@ -15,12 +15,14 @@ describe("useScrollAnimation", () => {
     disconnectMock = vi.fn();
 
     // Mock IntersectionObserver
-    global.IntersectionObserver = vi.fn().mockImplementation(function (callback) {
-      intersectionCallback = callback;
-      this.observe = observeMock;
-      this.unobserve = unobserveMock;
-      this.disconnect = disconnectMock;
-    }) as any;
+    global.IntersectionObserver = vi
+      .fn()
+      .mockImplementation(function (callback) {
+        intersectionCallback = callback;
+        this.observe = observeMock;
+        this.unobserve = unobserveMock;
+        this.disconnect = disconnectMock;
+      }) as any;
   });
 
   it("should initialize with isVisible false", () => {

package/test/nuxt/useShopBiteConfig.test.ts

@@ -2,15 +2,13 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { mockNuxtImport } from "@nuxt/test-utils/runtime";
 import { useShopBiteConfig } from "~/composables/useShopBiteConfig";
 
-const {
-  mockInvoke,
-  mockDeliveryTime,
-  mockIsCheckoutEnabled,
-} = vi.hoisted(() => ({
-  mockInvoke: vi.fn(),
-  mockDeliveryTime: { value: 0 },
-  mockIsCheckoutEnabled: { value: false },
-}));
+const { mockInvoke, mockDeliveryTime, mockIsCheckoutEnabled } = vi.hoisted(
+  () => ({
+    mockInvoke: vi.fn(),
+    mockDeliveryTime: { value: 0 },
+    mockIsCheckoutEnabled: { value: false },
+  }),
+);
 
 mockNuxtImport("useShopwareContext", () => () => ({
   apiClient: {
@@ -43,8 +41,8 @@ describe("useShopBiteConfig", () => {
     mockInvoke.mockResolvedValue({
       data: {
         deliveryTime: 45,
-        isCheckoutEnabled: true
-      }
+        isCheckoutEnabled: true,
+      },
     });
 
     const { refresh, deliveryTime, isCheckoutEnabled } = useShopBiteConfig();

package/test/nuxt/useTopSellers.test.ts

@@ -30,15 +30,18 @@ describe("useTopSellers", () => {
     const { loadTopSellers } = useTopSellers();
     const result = await loadTopSellers();
 
-    expect(mockInvoke).toHaveBeenCalledWith("getTopSellers post /product", expect.any(Object));
+    expect(mockInvoke).toHaveBeenCalledWith(
+      "getTopSellers post /product",
+      expect.any(Object),
+    );
     expect(result).toEqual(mockElements);
   });
 
   it("should return empty array on error", async () => {
     mockInvoke.mockRejectedValue(new Error("Network error"));
-    
+
     // Silence console.error for this test
-    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
 
     const { loadTopSellers } = useTopSellers();
     const result = await loadTopSellers();

package/test/nuxt/useWishlistActions.test.ts

@@ -2,7 +2,6 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { mockNuxtImport } from "@nuxt/test-utils/runtime";
 import { useWishlistActions } from "../../app/composables/useWishlistActions";
 
-
 const {
   mockAddProducts,
   mockRefreshCart,
@@ -53,7 +52,9 @@ describe("useWishlistActions", () => {
     const { clearWishlistHandler, isLoading } = useWishlistActions();
     await clearWishlistHandler();
     expect(mockClearWishlist).toHaveBeenCalled();
-    expect(mockToastAdd).toHaveBeenCalledWith(expect.objectContaining({ title: "Merkliste geleert" }));
+    expect(mockToastAdd).toHaveBeenCalledWith(
+      expect.objectContaining({ title: "Merkliste geleert" }),
+    );
     expect(isLoading.value).toBe(false);
   });
 
@@ -63,11 +64,18 @@ describe("useWishlistActions", () => {
 
     await addSingleItemToCart(mockProduct);
 
-    expect(mockAddProducts).toHaveBeenCalledWith([{ id: "prod-1", quantity: 1, type: "product" }]);
+    expect(mockAddProducts).toHaveBeenCalledWith([
+      { id: "prod-1", quantity: 1, type: "product" },
+    ]);
     expect(mockRefreshCart).toHaveBeenCalled();
     expect(mockTriggerProductAdded).toHaveBeenCalled();
-    expect(mockToastAdd).toHaveBeenCalledWith(expect.objectContaining({ title: "In den Warenkorb gelegt" }));
-    expect(mockTrackEvent).toHaveBeenCalledWith("add_to_cart", expect.any(Object));
+    expect(mockToastAdd).toHaveBeenCalledWith(
+      expect.objectContaining({ title: "In den Warenkorb gelegt" }),
+    );
+    expect(mockTrackEvent).toHaveBeenCalledWith(
+      "add_to_cart",
+      expect.any(Object),
+    );
   });
 
   it("should warn when adding a base product with variants", async () => {
@@ -77,7 +85,9 @@ describe("useWishlistActions", () => {
     await addSingleItemToCart(baseProduct);
 
     expect(mockAddProducts).not.toHaveBeenCalled();
-    expect(mockToastAdd).toHaveBeenCalledWith(expect.objectContaining({ title: "Variante erforderlich" }));
+    expect(mockToastAdd).toHaveBeenCalledWith(
+      expect.objectContaining({ title: "Variante erforderlich" }),
+    );
   });
 
   it("should add all items to cart", async () => {
@@ -94,7 +104,9 @@ describe("useWishlistActions", () => {
       { id: "p1", quantity: 1, type: "product" },
       { id: "p2", quantity: 1, type: "product" },
     ]);
-    expect(mockToastAdd).toHaveBeenCalledWith(expect.objectContaining({ title: "Produkte hinzugefügt" }));
+    expect(mockToastAdd).toHaveBeenCalledWith(
+      expect.objectContaining({ title: "Produkte hinzugefügt" }),
+    );
     expect(isAddingToCart.value).toBe(false);
   });
 
@@ -117,8 +129,12 @@ describe("useWishlistActions", () => {
     expect(mockAddProducts).toHaveBeenCalledWith([
       { id: "p1", quantity: 1, type: "product" },
     ]);
-    expect(mockToastAdd).toHaveBeenCalledWith(expect.objectContaining({
-      description: expect.stringContaining("1 Produkte hinzugefügt. 1 Produkt(e) übersprungen")
-    }));
+    expect(mockToastAdd).toHaveBeenCalledWith(
+      expect.objectContaining({
+        description: expect.stringContaining(
+          "1 Produkte hinzugefügt. 1 Produkt(e) übersprungen",
+        ),
+      }),
+    );
   });
 });

package/app/utils/businessHours.ts

@@ -1,119 +0,0 @@
-import { setTime } from "./time";
-import { isClosedHoliday } from "~/utils/holidays";
-
-export type ServiceInterval = { start: Date; end: Date };
-
-export function isTuesday(date: Date): boolean {
-  return date.getDay() === 2;
-}
-
-export function isSaturday(date: Date): boolean {
-  return date.getDay() === 6;
-}
-
-export function getServiceIntervals(date: Date): Array<ServiceInterval> {
-  if (isTuesday(date)) return [];
-
-  const lunchStart = setTime(date, 11, 30);
-  const lunchEnd = setTime(date, 14, 30);
-  const dinnerStart = setTime(date, 17, 30);
-  const dinnerEnd = isSaturday(date)
-    ? setTime(date, 23, 30)
-    : setTime(date, 23, 0);
-
-  if (isSaturday(date)) {
-    // Saturday: only dinner, no lunch
-    return [{ start: dinnerStart, end: dinnerEnd }];
-  }
-
-  return [
-    { start: lunchStart, end: lunchEnd },
-    { start: dinnerStart, end: dinnerEnd },
-  ];
-}
-
-export function getEarliestSelectableTime(
-  currentTime: Date,
-  currentDeliveryTime: number | null,
-): Date {
-  const earliest = new Date(currentTime);
-  earliest.setMinutes(earliest.getMinutes() + (currentDeliveryTime ?? 30));
-  earliest.setSeconds(0, 0);
-  return earliest;
-}
-
-export function getNextOpeningTime(now: Ref<Date>): string | null {
-  const currentDate = now.value;
-
-  // Check if closed for holiday
-  if (isClosedHoliday(currentDate)) {
-    return "13.08."; // Based on your existing code
-  }
-
-  // Check today's intervals
-  const todayIntervals = getServiceIntervals(currentDate);
-  const currentTime = currentDate.getTime();
-
-  // Find next opening today
-  for (const interval of todayIntervals) {
-    if (interval.start.getTime() > currentTime) {
-      const hours = interval.start.getHours().toString().padStart(2, "0");
-      const minutes = interval.start.getMinutes().toString().padStart(2, "0");
-      return `${hours}:${minutes} Uhr`;
-    }
-  }
-
-  // Check tomorrow
-  const tomorrow = new Date(currentDate);
-  tomorrow.setDate(tomorrow.getDate() + 1);
-  tomorrow.setHours(0, 0, 0, 0);
-
-  // Try up to 7 days ahead to find next opening
-  for (let i = 0; i < 7; i++) {
-    const checkDate = new Date(tomorrow);
-    checkDate.setDate(checkDate.getDate() + i);
-
-    const intervals = getServiceIntervals(checkDate);
-    if (intervals.length > 0) {
-      const nextOpen = intervals[0].start;
-      const dayName = [
-        "Sonntag",
-        "Montag",
-        "Dienstag",
-        "Mittwoch",
-        "Donnerstag",
-        "Freitag",
-        "Samstag",
-      ][nextOpen.getDay()];
-      const hours = nextOpen.getHours().toString().padStart(2, "0");
-      const minutes = nextOpen.getMinutes().toString().padStart(2, "0");
-
-      if (i === 0) {
-        return `morgen um ${hours}:${minutes} Uhr`;
-      }
-      return `${dayName} um ${hours}:${minutes} Uhr`;
-    }
-  }
-
-  return null;
-}
-
-export function findActiveInterval(
-  currentTime: Date,
-  currentDeliveryTime: number | null,
-): ServiceInterval | null {
-  const intervals = getServiceIntervals(currentTime);
-  const earliest = getEarliestSelectableTime(
-    currentTime,
-    currentDeliveryTime ?? 30,
-  );
-
-  if (intervals.length === 0) return null;
-
-  const current = intervals.find(
-    (interval) => earliest >= interval.start && earliest <= interval.end,
-  );
-  if (current) return current;
-
-  return intervals.find((interval) => interval.start > earliest) ?? null;
-}

package/app/utils/holidays.ts

@@ -1,43 +0,0 @@
-export function isClosedHoliday(date: Date): boolean {
-  // Format date as YYYY-MM-DD for comparison
-  const formattedDate = formatDateYYYYMMDD(date);
-
-  // List of holidays (YYYY-MM-DD format)
-  const holidays = [
-    "2025-07-21",
-    "2025-07-22",
-    "2025-07-23",
-    "2025-07-24",
-    "2025-07-25",
-    "2025-07-26",
-    "2025-07-27",
-    "2025-07-28",
-    "2025-07-29",
-    "2025-07-30",
-    "2025-07-31",
-    "2025-08-01",
-    "2025-08-02",
-    "2025-08-03",
-    "2025-08-04",
-    "2025-08-05",
-    "2025-08-06",
-    "2025-08-07",
-    "2025-08-08",
-    "2025-08-09",
-  ];
-
-  return holidays.includes(formattedDate);
-}
-
-/**
- * Formats a date as YYYY-MM-DD
- * @param date The date to format
- * @returns The formatted date string
- */
-function formatDateYYYYMMDD(date: Date): string {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-
-  return `${year}-${month}-${day}`;
-}

package/app/utils/storeHours.ts

@@ -1,8 +0,0 @@
-// utils/storeHours.ts
-import { getServiceIntervals } from "~/utils/businessHours";
-
-export function isStoreOpen(date: Date = new Date()): boolean {
-  const intervals = getServiceIntervals(date);
-  if (intervals.length === 0) return false;
-  return intervals.some(({ start, end }) => date >= start && date <= end);
-}