@shopbite-de/storefront 1.4.0 → 1.4.1

package/app/app.vue

@@ -1,7 +1,6 @@
 <script setup lang="ts">
 import type { Schemas } from "#shopware";
 import * as Sentry from "@sentry/nuxt";
-import { getNextOpeningTime } from "~/utils/businessHours";
 import type { Toast } from "#ui/composables/useToast";
 
 // Composables

package/app/utils/businessHours.ts

@@ -1,6 +1,3 @@
-import { setTime } from "./time";
-import { isClosedHoliday } from "~/utils/holidays";
-
 export type ServiceInterval = { start: Date; end: Date };
 
 export function isTuesday(date: Date): boolean {
@@ -45,54 +42,52 @@ export function getEarliestSelectableTime(
 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);
+  // Try up to 60 days ahead to find next opening (covers long holiday periods)
+  for (let i = 0; i < 60; i++) {
+    const checkDate = new Date(currentDate);
     checkDate.setDate(checkDate.getDate() + i);
+    checkDate.setHours(12, 0, 0, 0); // Set to midday to avoid timezone issues
+
+    // Skip holidays
+    if (isClosedHoliday(checkDate)) continue;
 
     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`;
+    if (intervals.length === 0) continue;
+
+    // For today, check if there's still an opening coming
+    if (i === 0) {
+      for (const interval of intervals) {
+        if (interval.start.getTime() > currentDate.getTime()) {
+          const hours = interval.start.getHours().toString().padStart(2, "0");
+          const minutes = interval.start
+            .getMinutes()
+            .toString()
+            .padStart(2, "0");
+          return `${hours}:${minutes} Uhr`;
+        }
       }
-      return `${dayName} um ${hours}:${minutes} Uhr`;
+      continue; // Today's openings have passed, check next days
+    }
+
+    const nextOpen = intervals[0].start;
+    const day = nextOpen.getDate().toString().padStart(2, "0");
+    const month = (nextOpen.getMonth() + 1).toString().padStart(2, "0");
+    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 === 1) {
+      return `morgen um ${hours}:${minutes} Uhr`;
     }
+    return `${dayName}, ${day}.${month}. um ${hours}:${minutes} Uhr`;
   }
 
   return null;

package/app/utils/holidays.ts

@@ -1,30 +1,11 @@
-export function isClosedHoliday(date: Date): boolean {
+export function isClosedHoliday(date?: Date): boolean {
+  // Use provided date or current date
+  const checkDate = date ?? new Date();
   // Format date as YYYY-MM-DD for comparison
-  const formattedDate = formatDateYYYYMMDD(date);
+  const formattedDate = formatDateYYYYMMDD(checkDate);
 
   // 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",
-  ];
+  const holidays = ["2025-12-31", "2026-01-01"];
 
   return holidays.includes(formattedDate);
 }

package/app/utils/storeHours.ts

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

package/nuxt.config.ts

@@ -110,7 +110,7 @@ export default defineNuxtConfig({
     manifest: {
       name: "ShopBite",
       short_name: "ShopBite",
-      theme_color: "#4d7c0f",
+      theme_color: "#ff5b00",
       icons: [
         {
           src: "dark/Logo.svg",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shopbite-de/storefront",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "main": "nuxt.config.ts",
   "description": "Shopware storefront for food delivery shops",
   "keywords": [

package/playwright.config.ts

@@ -1,8 +1,8 @@
-import { defineConfig, devices } from '@playwright/test';
+import { defineConfig, devices } from "@playwright/test";
 import type { ConfigOptions } from "@nuxt/test-utils/playwright";
 import { fileURLToPath } from "node:url";
 import dotenv from "dotenv";
-import path from 'path';
+import path from "path";
 
 dotenv.config({ path: path.resolve(".env.test") });
 

package/test/nuxt/useAddToCart.test.ts

@@ -10,7 +10,7 @@ const {
   mockRefreshCart,
   mockToastAdd,
   mockTriggerProductAdded,
-  mockTrackEvent
+  mockTrackEvent,
 } = vi.hoisted(() => ({
   mockAddProducts: vi.fn(),
   mockRefreshCart: vi.fn(),
@@ -43,17 +43,17 @@ mockNuxtImport("useTrackEvent", () => {
 });
 
 // Provide the mocks globally or in a way that they are picked up
-vi.stubGlobal('useCart', () => ({
+vi.stubGlobal("useCart", () => ({
   addProducts: mockAddProducts,
   refreshCart: mockRefreshCart,
 }));
-vi.stubGlobal('useToast', () => ({
+vi.stubGlobal("useToast", () => ({
   add: mockToastAdd,
 }));
-vi.stubGlobal('useProductEvents', () => ({
+vi.stubGlobal("useProductEvents", () => ({
   triggerProductAdded: mockTriggerProductAdded,
 }));
-vi.stubGlobal('useTrackEvent', mockTrackEvent);
+vi.stubGlobal("useTrackEvent", mockTrackEvent);
 
 describe("useAddToCart", () => {
   const mockProduct = {
@@ -114,7 +114,7 @@ describe("useAddToCart", () => {
   it("should add simple product to cart", async () => {
     const { setSelectedProduct, addToCart, isLoading } = useAddToCart();
     setSelectedProduct(mockProduct);
-    
+
     mockAddProducts.mockResolvedValue({ id: "cart-123" });
     mockRefreshCart.mockResolvedValue({});
 
@@ -131,7 +131,10 @@ describe("useAddToCart", () => {
     expect(mockRefreshCart).toHaveBeenCalled();
     expect(mockToastAdd).toHaveBeenCalled();
     expect(mockTriggerProductAdded).toHaveBeenCalled();
-    expect(mockTrackEvent).toHaveBeenCalledWith("add_to_cart", expect.any(Object));
+    expect(mockTrackEvent).toHaveBeenCalledWith(
+      "add_to_cart",
+      expect.any(Object),
+    );
   });
 
   it("should add product with extras to cart as container", async () => {

package/test/nuxt/useDeliveryTime.test.ts

@@ -42,7 +42,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 +54,15 @@ 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",
+      );
     }
   });
 });

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",
+        ),
+      }),
+    );
   });
 });