@mohasinac/appkit 2.3.1 → 2.4.0

package/dist/features/whatsapp-bot/helpers/whatsapp.d.ts

@@ -1,4 +1,4 @@
-import type { CheckoutMessageInput, StatusNotificationInput, WebhookVerifyInput, IncomingWebhookPayload, SendWhatsAppInput, StatusMessageInput } from "../types";
+import type { CheckoutMessageInput, StatusNotificationInput, WebhookVerifyInput, IncomingWebhookPayload, SendWhatsAppInput, StatusMessageInput, WaBusinessSendInput, CatalogSyncInput, CatalogSyncResult, PurchaseAnnouncementInput } from "../types";
 export declare function buildCheckoutMessageURL(input: CheckoutMessageInput): string;
 export declare function buildStatusNotificationURL(input: StatusNotificationInput): string;
 export declare function verifyWebhookSignature(input: WebhookVerifyInput): boolean;
@@ -13,6 +13,28 @@ export declare function parseIncomingWebhookPayload(rawBody: string, contentType
  * Pass a custom `statusMessages` map to override the defaults.
  */
 export declare function buildStatusMessage(input: StatusMessageInput, statusMessages?: Record<string, string>): string;
+/**
+ * Send a WhatsApp message via Meta WhatsApp Business Cloud API.
+ * Distinct from the Twilio-based sendWhatsAppMessage — used for server-initiated
+ * platform announcements. Returns true on success, false on any failure.
+ */
+export declare function sendWhatsAppBusinessMessage(input: WaBusinessSendInput): Promise<boolean>;
+/**
+ * Sync a store's products to a Meta Commerce Catalog via items_batch API.
+ * Batches at 50 items per call (Meta limit). Returns aggregate results.
+ */
+export declare function syncProductsToCatalog(input: CatalogSyncInput): Promise<CatalogSyncResult>;
+/**
+ * Build a plain-text purchase announcement message for WhatsApp.
+ * Sent to admin numbers and store owner when a new order is placed.
+ */
+export declare function buildPurchaseAnnouncementMessage(input: PurchaseAnnouncementInput): string;
+/**
+ * Build a wa.me share link with a pre-filled message.
+ * Opens WhatsApp contact picker — user selects group manually.
+ * This is the only API-compliant way to target a WhatsApp group.
+ */
+export declare function buildGroupShareLink(message: string): string;
 /**
  * Send an outbound WhatsApp message via Twilio REST API.
  * Returns true on success, false on failure.

package/dist/features/whatsapp-bot/helpers/whatsapp.js

@@ -1,5 +1,6 @@
 import { createHmac, timingSafeEqual } from "crypto";
 import { getDefaultCurrencySymbol, getDefaultLocale, } from "../../../core/baseline-resolver";
+const META_GRAPH_BASE = "https://graph.facebook.com/v20.0";
 export function buildCheckoutMessageURL(input) {
     const { waNumber, cart, total, address, isPreorder = false } = input;
     const prefix = isPreorder ? "\uD83D\uDD16 *PRE-ORDER*\n\n" : "";
@@ -97,6 +98,109 @@ export function buildStatusMessage(input, statusMessages = DEFAULT_STATUS_MESSAG
         : "";
     return template.replace("{id}", orderId).replace("{tracking}", trackingLine);
 }
+/**
+ * Send a WhatsApp message via Meta WhatsApp Business Cloud API.
+ * Distinct from the Twilio-based sendWhatsAppMessage — used for server-initiated
+ * platform announcements. Returns true on success, false on any failure.
+ */
+export async function sendWhatsAppBusinessMessage(input) {
+    const { toPhone, message, phoneNumberId, accessToken } = input;
+    const cleanPhone = toPhone.replace(/\D/g, "");
+    if (!cleanPhone || !phoneNumberId || !accessToken)
+        return false;
+    try {
+        const res = await fetch(`${META_GRAPH_BASE}/${phoneNumberId}/messages`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({
+                messaging_product: "whatsapp",
+                to: cleanPhone,
+                type: "text",
+                text: { body: message },
+            }),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sync a store's products to a Meta Commerce Catalog via items_batch API.
+ * Batches at 50 items per call (Meta limit). Returns aggregate results.
+ */
+export async function syncProductsToCatalog(input) {
+    const { catalogId, accessToken, products } = input;
+    const result = {
+        handles: [],
+        successCount: 0,
+        failureCount: 0,
+        errors: [],
+    };
+    const BATCH_SIZE = 50;
+    for (let i = 0; i < products.length; i += BATCH_SIZE) {
+        const batch = products.slice(i, i + BATCH_SIZE);
+        const requests = batch.map((p) => ({
+            method: "UPDATE",
+            retailer_id: p.id,
+            data: {
+                name: p.title,
+                description: p.description,
+                // Meta expects "<amount> <ISO_CURRENCY>" e.g. "450.00 INR"
+                price: `${(p.price / 100).toFixed(2)} ${p.currency}`,
+                image_url: p.imageUrl,
+                availability: p.availability,
+                condition: p.condition,
+                ...(p.link ? { url: p.link } : {}),
+            },
+        }));
+        try {
+            const res = await fetch(`${META_GRAPH_BASE}/${catalogId}/items_batch`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                body: JSON.stringify({ requests }),
+            });
+            const json = (await res.json());
+            if (res.ok && json.handles) {
+                result.handles.push(...json.handles);
+                result.successCount += batch.length;
+            }
+            else {
+                result.failureCount += batch.length;
+                result.errors.push(json.error?.message ?? `Batch ${i / BATCH_SIZE + 1} failed`);
+            }
+        }
+        catch (err) {
+            result.failureCount += batch.length;
+            result.errors.push(String(err));
+        }
+    }
+    return result;
+}
+/**
+ * Build a plain-text purchase announcement message for WhatsApp.
+ * Sent to admin numbers and store owner when a new order is placed.
+ */
+export function buildPurchaseAnnouncementMessage(input) {
+    const { buyerName, firstItemName, additionalItemCount, totalAmount, orderId } = input;
+    const extra = additionalItemCount > 0 ? ` + ${additionalItemCount} more item${additionalItemCount > 1 ? "s" : ""}` : "";
+    const amount = (totalAmount / 100).toLocaleString("en-IN");
+    return `🛍️ New order! ${buyerName} purchased ${firstItemName}${extra} for ₹${amount}. Order #${orderId}`;
+}
+/**
+ * Build a wa.me share link with a pre-filled message.
+ * Opens WhatsApp contact picker — user selects group manually.
+ * This is the only API-compliant way to target a WhatsApp group.
+ */
+export function buildGroupShareLink(message) {
+    return `https://wa.me/?text=${encodeURIComponent(message)}`;
+}
 /**
  * Send an outbound WhatsApp message via Twilio REST API.
  * Returns true on success, false on failure.

package/dist/features/whatsapp-bot/server.d.ts

@@ -4,3 +4,4 @@
  * Server-only entry point for WhatsApp bot helpers (crypto operations).
  */
 export * from "./helpers/whatsapp";
+export * from "./types";

package/dist/features/whatsapp-bot/server.js

@@ -4,3 +4,4 @@
  * Server-only entry point for WhatsApp bot helpers (crypto operations).
  */
 export * from "./helpers/whatsapp";
+export * from "./types";

package/dist/features/whatsapp-bot/types/index.d.ts

@@ -40,6 +40,55 @@ export interface SendWhatsAppInput {
     /** Twilio from number, e.g. "whatsapp:+14155238886" */
     fromNumber: string;
 }
+/** Input for sending a message via Meta WhatsApp Business Cloud API. */
+export interface WaBusinessSendInput {
+    /** Digits-only phone number with country code, e.g. "919876543210" */
+    toPhone: string;
+    message: string;
+    /** Meta Phone Number ID (from Meta for Developers > App > WhatsApp > API Setup) */
+    phoneNumberId: string;
+    /** Meta system user access token */
+    accessToken: string;
+}
+/** A product mapped to the Meta Commerce API catalog item format. */
+export interface CatalogSyncProduct {
+    /** Firestore product ID — used as Meta `retailer_id` */
+    id: string;
+    title: string;
+    description: string;
+    /** Price in paise (will be converted to INR: price/100) */
+    price: number;
+    currency: string;
+    /** URL of the first product image */
+    imageUrl: string;
+    availability: "in stock" | "out of stock";
+    condition: "new" | "used" | "refurbished";
+    /** Canonical product page URL, e.g. /products/{slug} */
+    link?: string;
+}
+export interface CatalogSyncInput {
+    catalogId: string;
+    /** Meta access token with catalog management permission */
+    accessToken: string;
+    products: CatalogSyncProduct[];
+}
+export interface CatalogSyncResult {
+    /** Meta batch request handles */
+    handles: string[];
+    successCount: number;
+    failureCount: number;
+    errors: string[];
+}
+/** Input for building a purchase announcement message. */
+export interface PurchaseAnnouncementInput {
+    buyerName: string;
+    firstItemName: string;
+    /** 0 if only one item in the order */
+    additionalItemCount: number;
+    /** Total order amount in paise */
+    totalAmount: number;
+    orderId: string;
+}
 /** Known order status values — extend as needed per project. */
 export type OrderStatusKey = "pending_payment" | "payment_confirmed" | "processing" | "shipped" | "out_for_delivery" | "delivered" | "cancelled" | "refund_initiated" | string;
 export interface StatusMessageInput {

package/dist/features/wishlist/components/WishlistView.d.ts

@@ -2,9 +2,7 @@ import React from "react";
 import type { WishlistItem, WishlistResponse } from "../types";
 export type WishlistTab = "products" | "auctions" | "categories" | "stores";
 export interface WishlistViewProps {
-    /** Authenticated user id — required to fetch wishlist */
     userId?: string;
-    /** Optional initial SSR data */
     initialData?: WishlistResponse;
     labels?: {
         title?: string;
@@ -12,21 +10,13 @@ export interface WishlistViewProps {
         emptyTitle?: string;
         emptyDescription?: string;
     };
-    /** Render tab bar (receives active tab and setter) */
     renderTabs?: (activeTab: WishlistTab, onTabChange: (tab: WishlistTab) => void) => React.ReactNode;
-    /** Render search input */
     renderSearch?: (value: string, onChange: (v: string) => void) => React.ReactNode;
-    /** Render sort dropdown */
     renderSort?: (value: string, onChange: (v: string) => void) => React.ReactNode;
-    /** Render view mode toggle */
     renderViewToggle?: (mode: string, onToggle: (m: string) => void) => React.ReactNode;
-    /** Render the products grid */
     renderProducts?: (items: WishlistItem[], isLoading: boolean) => React.ReactNode;
-    /** Render coming-soon placeholder for non-products tabs */
     renderTabPlaceholder?: (tab: WishlistTab) => React.ReactNode;
-    /** Render bulk action bar */
     renderBulkActions?: (selectedIds: string[], onClearSelection: () => void) => React.ReactNode;
-    /** Render pagination */
     renderPagination?: (total: number) => React.ReactNode;
     className?: string;
 }

package/dist/features/wishlist/components/WishlistView.js

@@ -2,15 +2,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
 import { Div, Heading, Row, Text } from "../../../ui";
+import { useUrlTable } from "../../../react/hooks/useUrlTable";
 import { useWishlist } from "../hooks/useWishlist";
+const WISHLIST_SORT_OPTIONS = [
+    { value: "-addedAt", label: "Newest first" },
+    { value: "addedAt", label: "Oldest first" },
+    { value: "-price", label: "Price: high → low" },
+    { value: "price", label: "Price: low → high" },
+];
 export function WishlistView({ userId, initialData, labels = {}, renderTabs, renderSearch, renderSort, renderViewToggle, renderProducts, renderTabPlaceholder, renderBulkActions, renderPagination, className = "", }) {
-    const [activeTab, setActiveTab] = React.useState("products");
-    const [search, setSearch] = React.useState("");
-    const [sort, setSort] = React.useState("-addedAt");
-    const [viewMode, setViewMode] = React.useState("card");
+    const table = useUrlTable({ defaults: { sort: "-addedAt", view: "card" } });
     const [selectedIds, setSelectedIds] = React.useState([]);
+    const activeTab = table.get("tab") || "products";
+    const search = table.get("q");
+    const sort = table.get("sort") || "-addedAt";
+    const viewMode = table.get("view") || "card";
     const { items, total, isLoading } = useWishlist(userId ?? "", { initialData });
-    // Client-side filter + sort for products tab
     const displayedItems = React.useMemo(() => {
         if (activeTab !== "products")
             return [];
@@ -34,7 +41,7 @@ export function WishlistView({ userId, initialData, labels = {}, renderTabs, ren
         });
         return result;
     }, [items, activeTab, search, sort]);
-    return (_jsx(Div, { className: `min-h-screen ${className}`, children: _jsxs(Div, { className: "py-8 px-4 max-w-screen-xl mx-auto", children: [_jsx(Heading, { level: 1, className: "text-2xl font-bold mb-1", children: labels.title ?? "My Wishlist" }), total > 0 && (_jsx(Text, { variant: "secondary", className: "mb-4", children: labels.subtitle ?? `${total} saved items` })), renderTabs?.(activeTab, setActiveTab), activeTab === "products" && (_jsxs(Row, { wrap: true, gap: "3", className: "mb-4", children: [renderSearch?.(search, setSearch), renderSort?.(sort, setSort), renderViewToggle?.(viewMode, setViewMode)] })), selectedIds.length > 0 &&
+    return (_jsx(Div, { className: `min-h-screen ${className}`, children: _jsxs(Div, { className: "py-8 px-4 max-w-screen-xl mx-auto", children: [_jsx(Heading, { level: 1, className: "text-2xl font-bold mb-1", children: labels.title ?? "My Wishlist" }), total > 0 && (_jsx(Text, { variant: "secondary", className: "mb-4", children: labels.subtitle ?? `${total} saved items` })), renderTabs?.(activeTab, (tab) => table.set("tab", tab)), activeTab === "products" && (_jsxs(Row, { wrap: true, gap: "3", className: "mb-4", children: [renderSearch?.(search, (v) => table.set("q", v)), renderSort?.(sort, (v) => table.set("sort", v)), renderViewToggle?.(viewMode, (m) => table.set("view", m))] })), selectedIds.length > 0 &&
                     renderBulkActions?.(selectedIds, () => setSelectedIds([])), activeTab === "products"
                     ? renderProducts?.(displayedItems, isLoading)
                     : (renderTabPlaceholder?.(activeTab) ?? (_jsx(Div, { className: "py-16 text-center", children: _jsx(Text, { variant: "secondary", children: "Coming soon" }) }))), renderPagination?.(total)] }) }));

package/dist/features/wishlist/hooks/useGuestWishlist.d.ts

@@ -0,0 +1,20 @@
+import { type GuestWishlistItem } from "../utils/guest-wishlist";
+/**
+ * useGuestWishlist
+ *
+ * React state wrapper around guest wishlist storage.
+ */
+export declare function useGuestWishlist(): {
+    items: GuestWishlistItem[];
+    count: number;
+    countByType: (type: "product" | "auction" | "preorder" | "category" | "store") => number;
+    add: (itemId: string, type: "product" | "auction" | "preorder" | "category" | "store", snapshot?: {
+        title?: string;
+        image?: string;
+    }) => void;
+    remove: (itemId: string, type: "product" | "auction" | "preorder" | "category" | "store") => void;
+    isInWishlist: (itemId: string, type: "product" | "auction" | "preorder" | "category" | "store") => boolean;
+    clear: () => void;
+    getByType: (type: "product" | "auction" | "preorder" | "category" | "store") => GuestWishlistItem[];
+    isInitialized: boolean;
+};

package/dist/features/wishlist/hooks/useGuestWishlist.js

@@ -0,0 +1,49 @@
+"use client";
+import { useState, useEffect, useCallback } from "react";
+import { getGuestWishlistItems, addToGuestWishlist, removeFromGuestWishlist, isInGuestWishlist, clearGuestWishlist, getGuestWishlistByType, } from "../utils/guest-wishlist";
+/**
+ * useGuestWishlist
+ *
+ * React state wrapper around guest wishlist storage.
+ */
+export function useGuestWishlist() {
+    const [items, setItems] = useState([]);
+    const [isInitialized, setIsInitialized] = useState(false);
+    useEffect(() => {
+        setItems(getGuestWishlistItems());
+        setIsInitialized(true);
+    }, []);
+    const add = useCallback((itemId, type, snapshot) => {
+        const updated = addToGuestWishlist(itemId, type, snapshot);
+        setItems(updated);
+    }, []);
+    const remove = useCallback((itemId, type) => {
+        const updated = removeFromGuestWishlist(itemId, type);
+        setItems(updated);
+    }, []);
+    const isInWishlist = useCallback((itemId, type) => {
+        return isInGuestWishlist(itemId, type);
+    }, []);
+    const clear = useCallback(() => {
+        clearGuestWishlist();
+        setItems([]);
+    }, []);
+    const getByType = useCallback((type) => {
+        return getGuestWishlistByType(type);
+    }, []);
+    const count = items.length;
+    const countByType = (type) => {
+        return items.filter((i) => i.type === type).length;
+    };
+    return {
+        items,
+        count,
+        countByType,
+        add,
+        remove,
+        isInWishlist,
+        clear,
+        getByType,
+        isInitialized,
+    };
+}

package/dist/features/wishlist/hooks/useWishlist.js

@@ -8,6 +8,8 @@ export function useWishlist(userId, opts) {
         queryFn: () => apiClient.get(endpoint),
         initialData: opts?.initialData,
         enabled: opts?.enabled !== false && !!userId,
+        retry: 1,
+        staleTime: 30000,
     });
     const ids = new Set((query.data?.items ?? []).map((i) => i.productId));
     return {

package/dist/features/wishlist/hooks/useWishlistCount.d.ts

@@ -0,0 +1,15 @@
+/**
+ * useWishlistCount
+ *
+ * Returns wishlist count always from localStorage — same source for guest and
+ * authenticated users, so the badge is instant with no API round-trip.
+ *
+ * When userId changes from null → a real uid (login):
+ *   1. Fetches Firestore wishlist and merges into localStorage.
+ *   2. Pushes any guest-only localStorage items up to Firestore.
+ *
+ * While authenticated:
+ *   - Syncs localStorage → Firestore every 60 s.
+ *   - Also syncs when the user visits /wishlist or /cart.
+ */
+export declare function useWishlistCount(userId: string | null | undefined): number;

package/dist/features/wishlist/hooks/useWishlistCount.js

@@ -0,0 +1,95 @@
+"use client";
+import { useEffect, useRef } from "react";
+import { usePathname } from "next/navigation";
+import { useGuestWishlist } from "./useGuestWishlist";
+import { getGuestWishlistItems } from "../utils/guest-wishlist";
+const WISHLIST_API = "/api/wishlist";
+const WISHLIST_MERGE_API = "/api/wishlist/merge";
+const SYNC_MS = 60000;
+function getSyncableItems() {
+    return getGuestWishlistItems().filter((i) => ["product", "auction", "preorder"].includes(i.type));
+}
+function pushToFirestore() {
+    const items = getSyncableItems();
+    if (!items.length)
+        return;
+    fetch(WISHLIST_MERGE_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ items: items.map((i) => ({ productId: i.itemId })) }),
+    }).catch(() => { });
+}
+/**
+ * useWishlistCount
+ *
+ * Returns wishlist count always from localStorage — same source for guest and
+ * authenticated users, so the badge is instant with no API round-trip.
+ *
+ * When userId changes from null → a real uid (login):
+ *   1. Fetches Firestore wishlist and merges into localStorage.
+ *   2. Pushes any guest-only localStorage items up to Firestore.
+ *
+ * While authenticated:
+ *   - Syncs localStorage → Firestore every 60 s.
+ *   - Also syncs when the user visits /wishlist or /cart.
+ */
+export function useWishlistCount(userId) {
+    const { count, add } = useGuestWishlist();
+    const prevUserIdRef = useRef(undefined);
+    const mergedRef = useRef(false);
+    const pathname = usePathname();
+    // Merge on login: pull Firestore → localStorage, push guest items → Firestore
+    useEffect(() => {
+        const prev = prevUserIdRef.current;
+        prevUserIdRef.current = userId;
+        // Only fire on the null/undefined → real-uid transition
+        if (!userId || prev === userId)
+            return;
+        if (mergedRef.current)
+            return;
+        mergedRef.current = true;
+        async function merge() {
+            try {
+                // 1. Pull server wishlist into localStorage (handles new device login)
+                const resp = await fetch(WISHLIST_API);
+                if (resp.ok) {
+                    const json = await resp.json();
+                    const firestoreItems = json.data?.items ?? [];
+                    for (const item of firestoreItems) {
+                        add(item.productId, "product", {
+                            title: item.productTitle,
+                            image: item.productImage,
+                        });
+                    }
+                }
+                // 2. Push any guest-only items up to Firestore
+                pushToFirestore();
+            }
+            catch {
+                // Non-fatal — local count still shows correctly
+            }
+        }
+        void merge();
+    }, [userId, add]);
+    // Reset merge flag on logout so next login re-runs the merge
+    useEffect(() => {
+        if (!userId)
+            mergedRef.current = false;
+    }, [userId]);
+    // 60 s periodic sync: localStorage → Firestore
+    useEffect(() => {
+        if (!userId)
+            return;
+        const id = setInterval(pushToFirestore, SYNC_MS);
+        return () => clearInterval(id);
+    }, [userId]);
+    // Extra sync when the user lands on /wishlist or /cart
+    useEffect(() => {
+        if (!userId || !pathname)
+            return;
+        if (/\/(wishlist|cart)(\/|$)/.test(pathname)) {
+            pushToFirestore();
+        }
+    }, [pathname, userId]);
+    return count;
+}

package/dist/features/wishlist/hooks/useWishlistWithGuest.d.ts

@@ -0,0 +1,56 @@
+import type { WishlistResponse } from "../types";
+interface UseWishlistWithGuestOptions {
+    initialData?: WishlistResponse;
+    enabled?: boolean;
+    endpoint?: string;
+}
+/**
+ * useWishlistWithGuest
+ *
+ * Unified wishlist hook that uses API for authenticated users
+ * and localStorage for guest users.
+ */
+export declare function useWishlistWithGuest(userId: string | null | undefined, opts?: UseWishlistWithGuestOptions): {
+    items: import("..").WishlistItem[];
+    total: number;
+    wishlistedIds: Set<string>;
+    isWishlisted: (productId: string) => boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WishlistResponse, Error>>;
+    isGuest: boolean;
+    guestWishlist?: undefined;
+} | {
+    items: {
+        id: string;
+        productId: string;
+        productTitle: string | undefined;
+        productImage: string | undefined;
+        productPrice: number;
+        productSlug: string;
+        addedAt: string | undefined;
+        type: "product" | "auction" | "preorder" | "category" | "store";
+    }[];
+    total: number;
+    wishlistedIds: Set<string>;
+    isWishlisted: (productId: string) => boolean;
+    isLoading: boolean;
+    error: null;
+    refetch: () => Promise<void>;
+    isGuest: boolean;
+    guestWishlist: {
+        items: import("..").GuestWishlistItem[];
+        count: number;
+        countByType: (type: "product" | "auction" | "preorder" | "category" | "store") => number;
+        add: (itemId: string, type: "product" | "auction" | "preorder" | "category" | "store", snapshot?: {
+            title?: string;
+            image?: string;
+        }) => void;
+        remove: (itemId: string, type: "product" | "auction" | "preorder" | "category" | "store") => void;
+        isInWishlist: (itemId: string, type: "product" | "auction" | "preorder" | "category" | "store") => boolean;
+        clear: () => void;
+        getByType: (type: "product" | "auction" | "preorder" | "category" | "store") => import("..").GuestWishlistItem[];
+        isInitialized: boolean;
+    };
+};
+export {};

package/dist/features/wishlist/hooks/useWishlistWithGuest.js

@@ -0,0 +1,57 @@
+"use client";
+import { useWishlist } from "./useWishlist";
+import { useGuestWishlist } from "./useGuestWishlist";
+/**
+ * useWishlistWithGuest
+ *
+ * Unified wishlist hook that uses API for authenticated users
+ * and localStorage for guest users.
+ */
+export function useWishlistWithGuest(userId, opts) {
+    const isAuthenticated = !!userId;
+    // For authenticated users
+    const authenticatedWishlist = useWishlist(userId ?? "", {
+        ...opts,
+        enabled: opts?.enabled !== false && isAuthenticated,
+    });
+    // For guest users
+    const guestWishlist = useGuestWishlist();
+    // Return appropriate wishlist based on authentication status
+    if (isAuthenticated) {
+        return {
+            items: authenticatedWishlist.items,
+            total: authenticatedWishlist.total,
+            wishlistedIds: authenticatedWishlist.wishlistedIds,
+            isWishlisted: authenticatedWishlist.isWishlisted,
+            isLoading: authenticatedWishlist.isLoading,
+            error: authenticatedWishlist.error,
+            refetch: authenticatedWishlist.refetch,
+            isGuest: false,
+        };
+    }
+    else {
+        // Convert guest items to wishlist items format
+        const items = guestWishlist.items.map((item) => ({
+            id: `${item.type}-${item.itemId}`,
+            productId: item.type === "product" ? item.itemId : "",
+            productTitle: item.title,
+            productImage: item.image,
+            productPrice: 0,
+            productSlug: item.itemId,
+            addedAt: item.addedAt,
+            type: item.type,
+        }));
+        const ids = new Set(items.map((i) => i.productId).filter(Boolean));
+        return {
+            items,
+            total: guestWishlist.count,
+            wishlistedIds: ids,
+            isWishlisted: (productId) => ids.has(productId),
+            isLoading: !guestWishlist.isInitialized,
+            error: null,
+            refetch: async () => { },
+            isGuest: true,
+            guestWishlist, // Expose guest wishlist for add/remove operations
+        };
+    }
+}

package/dist/features/wishlist/index.d.ts

@@ -4,6 +4,9 @@ export * from "./columns";
 export * from "./hooks/useWishlist";
 export * from "./hooks/useUserWishlist";
 export * from "./hooks/useWishlistToggle";
+export * from "./hooks/useGuestWishlist";
+export * from "./hooks/useWishlistWithGuest";
+export * from "./utils/guest-wishlist";
 export * from "./components";
 export type { UserWishlistItem } from "./repository/user-wishlist.repository";
 export { manifest } from "./manifest";

package/dist/features/wishlist/index.js

@@ -4,5 +4,8 @@ export * from "./columns";
 export * from "./hooks/useWishlist";
 export * from "./hooks/useUserWishlist";
 export * from "./hooks/useWishlistToggle";
+export * from "./hooks/useGuestWishlist";
+export * from "./hooks/useWishlistWithGuest";
+export * from "./utils/guest-wishlist";
 export * from "./components";
 export { manifest } from "./manifest";

package/dist/features/wishlist/schemas/index.d.ts

@@ -23,8 +23,8 @@ export declare const wishlistItemSchema: z.ZodObject<{
     addedAt: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    userId: string;
     productId: string;
+    userId: string;
     productTitle?: string | undefined;
     productImage?: string | undefined;
     addedAt?: string | undefined;
@@ -34,8 +34,8 @@ export declare const wishlistItemSchema: z.ZodObject<{
     productStatus?: string | undefined;
 }, {
     id: string;
-    userId: string;
     productId: string;
+    userId: string;
     productTitle?: string | undefined;
     productImage?: string | undefined;
     addedAt?: string | undefined;

package/dist/features/wishlist/types/index.d.ts

@@ -14,3 +14,19 @@ export interface WishlistResponse {
     items: WishlistItem[];
     total: number;
 }
+/** Shape of the product data the GET /api/user/wishlist endpoint attaches via Promise.allSettled enrichment. */
+export interface WishlistProductData {
+    slug?: string;
+    title?: string;
+    price?: number;
+    currency?: string;
+    images?: string[];
+    status?: "draft" | "published" | "archived" | "sold" | "out_of_stock" | "discontinued";
+    isFeatured?: boolean;
+    isAuction?: boolean;
+    isPreOrder?: boolean;
+}
+/** WishlistItem enriched with inline product details returned by the wishlist GET endpoint. */
+export interface EnrichedWishlistItem extends WishlistItem {
+    product?: WishlistProductData;
+}