medusa-storefront-data 1.0.0 → 2.0.0

package/dist/server/guest.d.ts

@@ -1,109 +1,81 @@
+import { type GuestReturnItem } from "medusa-services/guest";
 /**
  * Compatibility wrapper for sendOTP
  */
-export declare function sendOTP(email: string, type?: string): Promise<{
-    success: boolean;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: any;
-} | {
-    success: boolean;
-    token: string;
-}>;
+export declare function sendOTP(email: string, type?: string): Promise<import("medusa-services/guest").GuestOtpResponse>;
 /**
  * Compatibility wrapper for verifyOTP
  */
-export declare function verifyOTP(email: string, token: string, otp: string): Promise<{
-    success: boolean;
-    token: any;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: any;
-    token?: undefined;
-}>;
+export declare function verifyOTP(email: string, token: string, otp: string): Promise<import("medusa-services/guest").GuestOtpResponse>;
 /**
  * Compatibility wrapper for listGuestOrders
  */
 export declare function listGuestOrders(token: string): Promise<{
-    orders: any[];
+    orders: {
+        id?: string;
+    }[];
     count: number;
 }>;
-export declare function requestGuestOTP(email: string): Promise<{
-    success: boolean;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: any;
-}>;
-export declare function verifyGuestOTP(email: string, otp: string): Promise<{
-    success: boolean;
-    token: any;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: any;
-    token?: undefined;
-}>;
+export declare function requestGuestOTP(email: string): Promise<import("medusa-services/guest").GuestOtpResponse>;
+export declare function verifyGuestOTP(email: string, otp: string): Promise<import("medusa-services/guest").GuestOtpResponse>;
 export declare function logoutGuest(): Promise<{
     success: boolean;
 }>;
 export declare function getGuestOrders(token?: string): Promise<{
     success: boolean;
-    orders: any;
-    error?: undefined;
+    error: string;
+    orders?: undefined;
 } | {
     success: boolean;
-    error: any;
-    orders?: undefined;
+    orders: Record<string, unknown>[];
+    error?: undefined;
 }>;
 export declare function getGuestOrder(id: string, token?: string): Promise<{
     success: boolean;
-    order: any;
-    error?: undefined;
+    error: string;
+    order?: undefined;
 } | {
     success: boolean;
-    error: any;
-    order?: undefined;
+    order: Record<string, unknown>;
+    error?: undefined;
 }>;
 export declare function cancelGuestOrder(orderId: string, token?: string): Promise<{
     success: boolean;
-    error?: undefined;
+    error: string;
 } | {
     success: boolean;
-    error: any;
+    error?: undefined;
 }>;
 export declare function getGuestOrderInvoice(orderId: string, token?: string): Promise<{
     success: boolean;
-    type: string;
-    data: any;
+    error: string;
+} | {
+    type: "pdf";
+    data: string;
+    success: boolean;
     error?: undefined;
 } | {
+    type: "json";
+    data: unknown;
     success: boolean;
-    error: any;
-    type?: undefined;
-    data?: undefined;
+    error?: undefined;
 }>;
 export declare function guestReorder(orderId: string, token?: string): Promise<{
     success: boolean;
-    data: any;
-    error?: undefined;
+    error: string;
+    data?: undefined;
 } | {
     success: boolean;
-    error: any;
-    data?: undefined;
+    data: import("medusa-services/orders").MedusaOrderReorderResponse;
+    error?: undefined;
 }>;
-export declare function createGuestReturn(orderId: string, items: {
-    id: string;
-    quantity: number;
-}[], reason_id?: string, note?: string, token?: string): Promise<{
+export declare function createGuestReturn(orderId: string, items: GuestReturnItem[], reason_id?: string, note?: string, token?: string): Promise<{
     success: boolean;
-    data: any;
-    error?: undefined;
+    error: string;
+    data?: undefined;
 } | {
     success: boolean;
-    error: any;
-    data?: undefined;
+    data: import("medusa-services/returns").StoreReturn;
+    error?: undefined;
 }>;
 //# sourceMappingURL=guest.d.ts.map

package/dist/server/guest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guest.d.ts","sourceRoot":"","sources":["../../src/server/guest.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA6B;;;;;;;;;GAQ/E;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;;;;;;;;GAIxE;AAID;;GAEG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM;;;GAmBlD;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM;;;;;;GAsBlD;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;;;;;;;;GAqC9D;AAED,wBAAsB,WAAW;;GAOhC;AAED,wBAAsB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM;;;;;;;;GA4BlD;AAED,wBAAsB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAgC7D;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;GA8BrE;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;;;GAoCzE;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;GA+BjE;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAoCpJ"}
+{"version":3,"file":"guest.d.ts","sourceRoot":"","sources":["../../src/server/guest.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAA;AAsB9B;;GAEG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA6B,6DAO/E;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,6DAExE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM;;aAOH,MAAM;;;GAUrD;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,6DAGlD;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,6DAe9D;AAED,wBAAsB,WAAW;;GAOhC;AAED,wBAAsB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAclD;AAED,wBAAsB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAkB7D;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;GAcrE;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;;;;;;GAczE;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAqBjE;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EAAE,EACxB,SAAS,CAAC,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM;;;;;;;;GAef"}

package/dist/server/guest.js

@@ -1,16 +1,27 @@
 "use server";
+import { medusaGuestOrderCancelSimple, medusaGuestOrderInvoice, medusaGuestOrderList, medusaGuestOrderRetrieve, medusaGuestOtpRequest, medusaGuestOtpVerify, } from "medusa-services/guest";
+import { medusaGuestOrderReorder } from "medusa-services/orders";
+import { medusaReturnCreateGuest } from "medusa-services/returns";
 import { cookies, headers } from "next/headers";
-import { getGuestAuthHeaders } from "../cookies";
-import { sdk } from "../config";
-const BACKEND_URL = process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL || "http://localhost:9000";
-const PUBLISHABLE_KEY = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY;
+import { getStoreClientOptions, getStoreClientOptionsWithToken, } from "../util/store-client";
+import { retrieveOrder } from "./orders";
+async function resolveGuestToken(token) {
+    if (token)
+        return token;
+    const headersStore = await headers();
+    const authHeader = headersStore.get("authorization");
+    const headerToken = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : undefined;
+    if (headerToken)
+        return headerToken;
+    const cookieStore = await cookies();
+    return cookieStore.get("_medusa_guest_jwt")?.value ?? null;
+}
 /**
  * Compatibility wrapper for sendOTP
  */
 export async function sendOTP(email, type = "email_verification") {
-    const res = await requestGuestOTP(email);
-    // The previous project expected a token or success. 
-    // We return a dummy token if successful because the UI checks for it.
+    const options = await getStoreClientOptions();
+    const res = await medusaGuestOtpRequest(email, options);
     if (res.success) {
         return { success: true, token: "otp_sent_successfully" };
     }
@@ -20,11 +31,8 @@ export async function sendOTP(email, type = "email_verification") {
  * Compatibility wrapper for verifyOTP
  */
 export async function verifyOTP(email, token, otp) {
-    // The previous implementation used 3 args, but guest.ts uses 2.
-    // We ignore the mid 'token' as per user's working code.
-    return await verifyGuestOTP(email, otp);
+    return verifyGuestOTP(email, otp);
 }
-import { retrieveOrder } from "./orders";
 /**
  * Compatibility wrapper for listGuestOrders
  */
@@ -33,76 +41,33 @@ export async function listGuestOrders(token) {
     if (!res.success) {
         throw new Error(res.error || "Failed to fetch orders");
     }
-    // Fetch full details for each order to ensure latest fulfillment_status is available
-    // because the custom list endpoint might not return all fields correctly.
     const fullOrders = await Promise.all((res.orders || []).map(async (order) => {
         try {
             return await retrieveOrder(order.id);
         }
-        catch (e) {
+        catch {
             return order;
         }
     }));
     return { orders: fullOrders, count: fullOrders.length };
 }
 export async function requestGuestOTP(email) {
-    const headers = {
-        "Content-Type": "application/json",
-    };
-    if (PUBLISHABLE_KEY)
-        headers["x-publishable-api-key"] = PUBLISHABLE_KEY;
-    try {
-        const res = await fetch(`${BACKEND_URL}/store/otp/request`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({ email }),
-            cache: "no-store",
-        });
-        if (!res.ok) {
-            const errorData = await res.json().catch(() => ({}));
-            throw new Error(errorData.message || "Failed to send OTP");
-        }
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: error.message };
-    }
+    const options = await getStoreClientOptions();
+    return medusaGuestOtpRequest(email, options);
 }
 export async function verifyGuestOTP(email, otp) {
-    const headers = {
-        "Content-Type": "application/json",
-    };
-    if (PUBLISHABLE_KEY)
-        headers["x-publishable-api-key"] = PUBLISHABLE_KEY;
-    try {
-        const res = await fetch(`${BACKEND_URL}/store/otp/verify`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({ email, otp }),
-            cache: "no-store",
+    const options = await getStoreClientOptions();
+    const res = await medusaGuestOtpVerify(email, otp, options);
+    if (res.success && res.token) {
+        const cookieStore = await cookies();
+        cookieStore.set("_medusa_guest_jwt", res.token, {
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            maxAge: 60 * 60 * 24,
+            path: "/",
         });
-        if (!res.ok) {
-            const errorData = await res.json().catch(() => ({}));
-            throw new Error(errorData.message || "Failed to verify OTP");
-        }
-        const data = await res.json();
-        if (data.token) {
-            const cookieStore = await cookies();
-            cookieStore.set("_medusa_guest_jwt", data.token, {
-                httpOnly: true,
-                secure: process.env.NODE_ENV === "production",
-                maxAge: 60 * 60 * 24, // 1 day
-                path: "/",
-            });
-        }
-        else {
-            throw new Error("No token returned");
-        }
-        return { success: true, token: data.token };
-    }
-    catch (error) {
-        return { success: false, error: error.message };
     }
+    return res;
 }
 export async function logoutGuest() {
     const cookieStore = await cookies();
@@ -113,192 +78,106 @@ export async function logoutGuest() {
     return { success: true };
 }
 export async function getGuestOrders(token) {
-    const cookieStore = await cookies();
-    const headersStore = await headers();
-    const authHeader = headersStore.get("authorization");
-    const headerToken = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : undefined;
-    const authToken = token || headerToken || cookieStore.get("_medusa_guest_jwt")?.value;
+    const authToken = await resolveGuestToken(token);
     if (!authToken)
         return { success: false, error: "Unauthorized" };
-    const requestHeaders = {
-        "Authorization": `Bearer ${authToken}`
-    };
-    if (PUBLISHABLE_KEY)
-        requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY;
     try {
-        const response = await sdk.client.fetch(`/store/guest-orders`, {
-            method: "GET",
-            headers: requestHeaders,
-            query: {
-                fields: "id,display_id,status,fulfillment_status,payment_status,created_at,currency_code,total,subtotal,tax_total,shipping_total,discount_total,metadata,email,*items,*items.variant,*items.variant.product"
-            },
-            cache: "no-store",
-        });
+        const options = await getStoreClientOptions();
+        const response = await medusaGuestOrderList(authToken, options);
         return { success: true, orders: response.orders || [] };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }
 export async function getGuestOrder(id, token) {
-    const cookieStore = await cookies();
-    const headersStore = await headers();
-    const authHeader = headersStore.get("authorization");
-    const headerToken = authHeader?.startsWith("Bearer ") ? authHeader.split(" ")[1] : undefined;
-    const authToken = token || headerToken || cookieStore.get("_medusa_guest_jwt")?.value;
+    const authToken = await resolveGuestToken(token);
     if (!authToken)
         return { success: false, error: "Unauthorized" };
-    const requestHeaders = {
-        "Authorization": `Bearer ${authToken}`
-    };
-    if (PUBLISHABLE_KEY)
-        requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY;
     try {
-        const response = await sdk.client.fetch(`/store/orders/${id}`, {
-            method: "GET",
-            headers: requestHeaders,
-            query: {
-                fields: "*payment_collections.payments,*items,*items.metadata,*items.variant,*items.variant.images,*items.variant.product,*items.variant.product.thumbnail,*items.variant.product.images,*items.product,*items.product.thumbnail,*items.product.images,*fulfillments,*fulfillments.items,*fulfillments.location_id,*returns,*returns.items,*cart,*shipping_address,*billing_address,*region,*shipping_methods"
-            },
-            cache: "no-store"
-        });
+        const options = await getStoreClientOptions();
+        const response = await medusaGuestOrderRetrieve(id, authToken, options);
         if (response.order) {
             return { success: true, order: response.order };
         }
-        else {
-            return { success: false, error: "Order not found" };
-        }
+        return { success: false, error: "Order not found" };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }
 export async function cancelGuestOrder(orderId, token) {
-    const authHeaders = await getGuestAuthHeaders();
-    const authToken = token || authHeaders.authorization?.split(" ")[1];
+    const authToken = await resolveGuestToken(token);
     if (!authToken)
         return { success: false, error: "Unauthorized" };
-    const requestHeaders = {
-        "Authorization": `Bearer ${authToken}`
-    };
-    if (PUBLISHABLE_KEY)
-        requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY;
     try {
-        const response = await fetch(`${BACKEND_URL}/store/guest-orders/${orderId}/cancel`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...requestHeaders
-            },
-            cache: "no-store",
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(errorData.message || "Failed to cancel order");
-        }
+        const options = await getStoreClientOptions();
+        await medusaGuestOrderCancelSimple(orderId, authToken, options);
         return { success: true };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }
 export async function getGuestOrderInvoice(orderId, token) {
-    const authHeaders = await getGuestAuthHeaders();
-    const authToken = token || authHeaders.authorization?.split(" ")[1];
+    const authToken = await resolveGuestToken(token);
     if (!authToken)
         return { success: false, error: "Unauthorized" };
-    const requestHeaders = {
-        "Authorization": `Bearer ${authToken}`
-    };
-    if (PUBLISHABLE_KEY)
-        requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY;
     try {
-        const response = await fetch(`${BACKEND_URL}/store/guest/invoice/download/${orderId}`, {
-            method: "GET",
-            headers: requestHeaders,
-            cache: "no-store",
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(errorData.message || "Failed to get invoice");
-        }
-        const contentType = response.headers.get("content-type");
-        if (contentType && contentType.includes("application/pdf")) {
-            const arrayBuffer = await response.arrayBuffer();
-            const base64 = Buffer.from(arrayBuffer).toString('base64');
-            return { success: true, type: 'pdf', data: base64 };
-        }
-        else {
-            const data = await response.json();
-            return { success: true, type: 'json', data };
-        }
+        const options = await getStoreClientOptions();
+        const result = await medusaGuestOrderInvoice(orderId, authToken, options);
+        return { success: true, ...result };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }
 export async function guestReorder(orderId, token) {
-    const authHeaders = await getGuestAuthHeaders();
-    const authToken = token || authHeaders.authorization?.split(" ")[1];
+    const authToken = await resolveGuestToken(token);
     if (!authToken)
         return { success: false, error: "Unauthorized" };
-    const requestHeaders = {
-        "Authorization": `Bearer ${authToken}`
-    };
-    if (PUBLISHABLE_KEY)
-        requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY;
     try {
-        const response = await fetch(`${BACKEND_URL}/store/guest-orders/${orderId}/reorder`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...requestHeaders
-            },
-            cache: "no-store",
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(errorData.message || "Failed to reorder");
+        const options = await getStoreClientOptionsWithToken(authToken);
+        const result = await medusaGuestOrderReorder(orderId, options);
+        if (!result.ok) {
+            throw new Error(typeof result.data.message === "string"
+                ? result.data.message
+                : "Failed to reorder");
         }
-        const data = await response.json();
-        return { success: true, data };
+        return { success: true, data: result.data };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }
 export async function createGuestReturn(orderId, items, reason_id, note, token) {
-    const authHeaders = await getGuestAuthHeaders();
-    const authToken = token || authHeaders.authorization?.split(" ")[1];
+    const authToken = await resolveGuestToken(token);
     if (!authToken)
         return { success: false, error: "Unauthorized" };
-    const requestHeaders = {
-        "Authorization": `Bearer ${authToken}`
-    };
-    if (PUBLISHABLE_KEY)
-        requestHeaders["x-publishable-api-key"] = PUBLISHABLE_KEY;
     try {
-        const response = await fetch(`${BACKEND_URL}/store/guest-orders/${orderId}/returns`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...requestHeaders
-            },
-            body: JSON.stringify({
-                items,
-                reason_id,
-                note
-            }),
-            cache: "no-store",
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(errorData.message || "Failed to create return request");
-        }
-        const data = await response.json();
+        const options = await getStoreClientOptionsWithToken(authToken);
+        const data = await medusaReturnCreateGuest(orderId, { items, reason_id, note }, options);
         return { success: true, data };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 }

package/dist/server/home.d.ts

@@ -0,0 +1,15 @@
+import { getRegion } from "./regions";
+export type HomePageData = {
+    region: Awaited<ReturnType<typeof getRegion>>;
+    collections: Array<Record<string, unknown>>;
+    categories: unknown[];
+    newArrivals: unknown[];
+    bestsellers: unknown[];
+    testimonials: unknown | null;
+    ratings: unknown[];
+};
+/**
+ * Parallel home page data loader (replaces per-page Promise.all boilerplate).
+ */
+export declare function loadHomePageData(countryCode: string): Promise<HomePageData | null>;
+//# sourceMappingURL=home.d.ts.map

package/dist/server/home.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"home.d.ts","sourceRoot":"","sources":["../../src/server/home.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAItC,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC;IAC9C,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5C,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,OAAO,EAAE,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA6CxF"}

package/dist/server/home.js

@@ -0,0 +1,45 @@
+"use server";
+import { listCollections } from "./collections";
+import { listCategories } from "./categories";
+import { listProductsWithSort, getProductsByTag } from "./products";
+import { getRegion } from "./regions";
+import { getTestimonialsFromConfig } from "./dynamic-config";
+import { fetchRatings } from "medusa-reviews-logic/server";
+/**
+ * Parallel home page data loader (replaces per-page Promise.all boilerplate).
+ */
+export async function loadHomePageData(countryCode) {
+    const region = await getRegion(countryCode);
+    if (!region)
+        return null;
+    const [collectionsResult, categoriesResult, newArrivalsResult, bestsellersResult, testimonialsData, allRatings,] = await Promise.all([
+        listCollections({ fields: "id, handle, title, metadata" }).catch(() => ({
+            collections: [],
+        })),
+        listCategories({ limit: 50 }).catch(() => []),
+        listProductsWithSort({
+            page: 1,
+            queryParams: { limit: 8 },
+            sortBy: "created_at",
+            countryCode,
+        }).catch(() => ({ response: { products: [] } })),
+        getProductsByTag({
+            tagValue: "bestseller",
+            limit: 10,
+            countryCode,
+        }).catch(() => []),
+        getTestimonialsFromConfig().catch(() => null),
+        fetchRatings(),
+    ]);
+    const collections = collectionsResult.collections ?? [];
+    const newArrivals = newArrivalsResult.response?.products ?? [];
+    return {
+        region,
+        collections: collections,
+        categories: categoriesResult ?? [],
+        newArrivals,
+        bestsellers: bestsellersResult ?? [],
+        testimonials: testimonialsData,
+        ratings: allRatings ?? [],
+    };
+}

package/dist/server/index.d.ts

@@ -18,4 +18,6 @@ export * from "./regions";
 export * from "./returns";
 export * from "./swaps";
 export * from "./variants";
+export * from "./wishlist";
+export * from "./home";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,yBAAyB,CAAA;AACvC,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,yBAAyB,CAAA;AACvC,cAAc,YAAY,CAAA;AAC1B,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,QAAQ,CAAA"}

package/dist/server/index.js

@@ -18,3 +18,5 @@ export * from "./regions";
 export * from "./returns";
 export * from "./swaps";
 export * from "./variants";
+export * from "./wishlist";
+export * from "./home";

package/dist/server/locale-actions.d.ts

@@ -7,7 +7,7 @@ export declare const getLocale: () => Promise<string | null>;
  */
 export declare const setLocaleCookie: (locale: string) => Promise<void>;
 /**
- * Updates the locale preference via SDK and stores in cookie.
+ * Updates the locale preference and stores in cookie.
  * Also updates the cart with the new locale if one exists.
  */
 export declare const updateLocale: (localeCode: string) => Promise<string>;

package/dist/server/locale-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locale-actions.d.ts","sourceRoot":"","sources":["../../src/server/locale-actions.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,eAAO,MAAM,SAAS,QAAa,OAAO,CAAC,MAAM,GAAG,IAAI,CAOvD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAU,QAAQ,MAAM,kBAQnD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,MAAM,CAmCrE,CAAA"}
+{"version":3,"file":"locale-actions.d.ts","sourceRoot":"","sources":["../../src/server/locale-actions.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,eAAO,MAAM,SAAS,QAAa,OAAO,CAAC,MAAM,GAAG,IAAI,CAOvD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAU,QAAQ,MAAM,kBAQnD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,MAAM,CA0BrE,CAAA"}