medusa-services 1.1.0

package/dist/reviews.js

@@ -0,0 +1,202 @@
+/**
+ * medusa-review-rating Store API helpers.
+ * @see package README (store routes under /store)
+ */
+function readEnv(name) {
+    try {
+        return process.env?.[name];
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Medusa store URL + publishable key from common Next.js / Node env vars.
+ */
+export function getMedusaReviewsClientOptionsFromEnv() {
+    const backendUrl = readEnv('NEXT_PUBLIC_MEDUSA_BACKEND_URL') ||
+        readEnv('MEDUSA_BACKEND_URL') ||
+        'http://localhost:9000';
+    const publishableApiKey = readEnv('NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY') || '';
+    return { backendUrl, publishableApiKey };
+}
+function normalizeAuth(authorization) {
+    const t = authorization.trim();
+    if (t.toLowerCase().startsWith('bearer '))
+        return t;
+    return `Bearer ${t}`;
+}
+function storeOrigin(options) {
+    return options.backendUrl.replace(/\/$/, '');
+}
+function buildPublicHeaders(options) {
+    return {
+        'x-publishable-api-key': options.publishableApiKey,
+        ...options.headers,
+    };
+}
+function buildAuthHeaders(options) {
+    return {
+        'Content-Type': 'application/json',
+        'x-publishable-api-key': options.publishableApiKey,
+        Authorization: normalizeAuth(options.authorization),
+        ...options.headers,
+    };
+}
+async function parseErrorMessage(response, fallbackPrefix) {
+    const data = await response.json().catch(() => ({}));
+    const msg = typeof data.message === 'string'
+        ? data.message
+        : typeof data.error === 'string'
+            ? data.error
+            : `${fallbackPrefix} (${response.status})`;
+    return msg;
+}
+/**
+ * GET /store/ratings — all product ratings, or filter by product_id.
+ */
+export async function medusaListRatings(options, query) {
+    const params = new URLSearchParams();
+    if (query?.product_id)
+        params.set('product_id', query.product_id);
+    const qs = params.toString();
+    const url = `${storeOrigin(options)}/store/ratings${qs ? `?${qs}` : ''}`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+            ...buildPublicHeaders(options),
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'List ratings failed'));
+    }
+    const data = (await response.json());
+    return { rating: data.rating ?? [] };
+}
+/**
+ * GET /store/products/:id/rating
+ */
+export async function medusaGetProductRatingSummary(productId, options) {
+    const url = `${storeOrigin(options)}/store/products/${encodeURIComponent(productId)}/rating`;
+    const response = await fetch(url, { method: 'GET', headers: buildPublicHeaders(options) });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'Rating request failed'));
+    }
+    const data = (await response.json());
+    const r = data.rating ?? {};
+    return {
+        averageRating: typeof r.average_rating === 'number' ? r.average_rating : 0,
+        totalReviews: typeof r.total_reviews === 'number' ? r.total_reviews : 0,
+    };
+}
+/**
+ * GET /store/products/:id/reviews
+ */
+export async function medusaListProductReviews(productId, options, query) {
+    const params = new URLSearchParams();
+    if (query?.status)
+        params.set('status', query.status);
+    if (query?.limit != null)
+        params.set('limit', String(query.limit));
+    if (query?.offset != null)
+        params.set('offset', String(query.offset));
+    const qs = params.toString();
+    const url = `${storeOrigin(options)}/store/products/${encodeURIComponent(productId)}/reviews${qs ? `?${qs}` : ''}`;
+    const response = await fetch(url, { method: 'GET', headers: buildPublicHeaders(options) });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'List reviews failed'));
+    }
+    return response.json();
+}
+/**
+ * POST /store/reviews
+ */
+export async function medusaSubmitReview(body, options) {
+    const url = `${storeOrigin(options)}/store/reviews`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: buildAuthHeaders(options),
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'Submit review failed'));
+    }
+    return response.json();
+}
+/**
+ * PUT /store/reviews/:id
+ */
+export async function medusaUpdateReview(reviewId, body, options) {
+    const url = `${storeOrigin(options)}/store/reviews/${encodeURIComponent(reviewId)}`;
+    const response = await fetch(url, {
+        method: 'PUT',
+        headers: buildAuthHeaders(options),
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'Update review failed'));
+    }
+    return response.json();
+}
+// --- Single review (store) ---
+/**
+ * GET /store/reviews/:id
+ */
+export async function medusaGetStoreReview(reviewId, options) {
+    const url = `${storeOrigin(options)}/store/reviews/${encodeURIComponent(reviewId)}`;
+    const response = await fetch(url, { method: 'GET', headers: buildPublicHeaders(options) });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'Get review failed'));
+    }
+    return response.json();
+}
+/**
+ * GET /store/reviews/me
+ */
+export async function medusaListCustomerReviews(options, query) {
+    const params = new URLSearchParams();
+    if (query?.product_id)
+        params.set('product_id', query.product_id);
+    if (query?.status)
+        params.set('status', query.status);
+    const qs = params.toString();
+    const url = `${storeOrigin(options)}/store/reviews/me${qs ? `?${qs}` : ''}`;
+    const response = await fetch(url, { method: 'GET', headers: buildAuthHeaders(options) });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'List customer reviews failed'));
+    }
+    return response.json();
+}
+/**
+ * GET /store/products/:id/reviews/me
+ */
+export async function medusaListCustomerProductReviews(productId, options) {
+    const url = `${storeOrigin(options)}/store/products/${encodeURIComponent(productId)}/reviews/me`;
+    const response = await fetch(url, { method: 'GET', headers: buildAuthHeaders(options) });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'List customer product reviews failed'));
+    }
+    return response.json();
+}
+/**
+ * POST /store/upload — multipart FormData with `files` field(s).
+ * Do not set Content-Type; the runtime sets the boundary.
+ */
+export async function medusaUploadStoreFiles(formData, options) {
+    const url = `${storeOrigin(options)}/store/upload`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'x-publishable-api-key': options.publishableApiKey,
+            Authorization: normalizeAuth(options.authorization),
+            ...options.headers,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response, 'Upload failed'));
+    }
+    const data = (await response.json());
+    return { files: data.files ?? [] };
+}

package/dist/store-api.d.ts

@@ -0,0 +1,20 @@
+export interface MedusaStoreClientOptions {
+    backendUrl: string;
+    publishableApiKey: string;
+    /**
+     * Send cookies (e.g. `_medusa_cart_id`, customer session) on cross-origin requests.
+     * @default "include"
+     */
+    credentials?: RequestCredentials;
+    /** Optional Bearer JWT (e.g. logged-in customer). */
+    authorization?: string;
+    headers?: Record<string, string>;
+}
+/** @deprecated Use MedusaStoreClientOptions */
+export type MedusaStoreCartClientOptions = MedusaStoreClientOptions;
+export declare function buildStoreHeaders(options: MedusaStoreClientOptions): Record<string, string>;
+export declare function parseStoreErrorMessage(response: Response, label?: string): Promise<string>;
+export declare function storeFetch(path: string, options: MedusaStoreClientOptions, init: RequestInit): Promise<Response>;
+export declare function fieldsQuery(fields?: string, defaultFields?: string): string;
+export declare function parseStoreJson<T>(response: Response, label?: string): Promise<T>;
+//# sourceMappingURL=store-api.d.ts.map

package/dist/store-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-api.d.ts","sourceRoot":"","sources":["../store-api.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,+CAA+C;AAC/C,MAAM,MAAM,4BAA4B,GAAG,wBAAwB,CAAC;AAYpE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAU3F;AAED,wBAAsB,sBAAsB,CACxC,QAAQ,EAAE,QAAQ,EAClB,KAAK,SAAkB,GACxB,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAsB,UAAU,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,wBAAwB,EACjC,IAAI,EAAE,WAAW,GAClB,OAAO,CAAC,QAAQ,CAAC,CAWnB;AAED,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAM3E;AAED,wBAAsB,cAAc,CAAC,CAAC,EAClC,QAAQ,EAAE,QAAQ,EAClB,KAAK,SAAkB,GACxB,OAAO,CAAC,CAAC,CAAC,CAKZ"}

package/dist/store-api.js

@@ -0,0 +1,55 @@
+function normalizeBackendUrl(backendUrl) {
+    return backendUrl.replace(/\/$/, "");
+}
+function normalizeAuth(authorization) {
+    const t = authorization.trim();
+    if (t.toLowerCase().startsWith("bearer "))
+        return t;
+    return `Bearer ${t}`;
+}
+export function buildStoreHeaders(options) {
+    const headers = {
+        "Content-Type": "application/json",
+        "x-publishable-api-key": options.publishableApiKey,
+        ...options.headers,
+    };
+    if (options.authorization) {
+        headers.Authorization = normalizeAuth(options.authorization);
+    }
+    return headers;
+}
+export async function parseStoreErrorMessage(response, label = "Store request") {
+    const data = await response.json().catch(() => ({}));
+    const msg = typeof data.message === "string"
+        ? data.message
+        : typeof data.error === "string"
+            ? data.error
+            : `${label} failed (${response.status})`;
+    return msg;
+}
+export async function storeFetch(path, options, init) {
+    const url = `${normalizeBackendUrl(options.backendUrl)}/store${path}`;
+    const credentials = options.credentials ?? "include";
+    return fetch(url, {
+        ...init,
+        credentials,
+        headers: {
+            ...buildStoreHeaders(options),
+            ...init.headers,
+        },
+    });
+}
+export function fieldsQuery(fields, defaultFields) {
+    const f = fields?.trim() || defaultFields || "";
+    if (!f)
+        return "";
+    const params = new URLSearchParams();
+    params.set("fields", f);
+    return `?${params.toString()}`;
+}
+export async function parseStoreJson(response, label = "Store request") {
+    if (!response.ok) {
+        throw new Error(await parseStoreErrorMessage(response, label));
+    }
+    return response.json();
+}

package/dist/swaps.d.ts

@@ -0,0 +1,33 @@
+import { type MedusaStoreClientOptions } from "./store-api";
+export interface CreateSwapPayload {
+    order_id: string;
+    return_items: Array<Record<string, unknown>>;
+    new_items: Array<Record<string, unknown>>;
+    reason?: string;
+    note?: string;
+}
+export interface StoreSwapListResponse {
+    swaps?: Array<Record<string, unknown>>;
+    count?: number;
+    swap?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * POST /store/swaps
+ */
+export declare function medusaSwapCreate(payload: CreateSwapPayload, options: MedusaStoreClientOptions): Promise<Record<string, unknown>>;
+/**
+ * POST /store/guest-orders/:id/swaps
+ */
+export declare function medusaSwapCreateGuest(orderId: string, payload: Omit<CreateSwapPayload, "order_id">, options: MedusaStoreClientOptions): Promise<Record<string, unknown>>;
+/**
+ * GET /store/swaps
+ */
+export declare function medusaSwapList(options: MedusaStoreClientOptions, query?: {
+    order_id?: string;
+}): Promise<StoreSwapListResponse>;
+/**
+ * GET /store/guest-orders/:id/swaps
+ */
+export declare function medusaSwapListGuest(orderId: string, options: MedusaStoreClientOptions): Promise<StoreSwapListResponse>;
+//# sourceMappingURL=swaps.d.ts.map

package/dist/swaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swaps.d.ts","sourceRoot":"","sources":["../swaps.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAExF,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IAClC,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAClC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAOlC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,EAC5C,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQlC;AAED;;GAEG;AACH,wBAAsB,cAAc,CAChC,OAAO,EAAE,wBAAwB,EACjC,KAAK,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9B,OAAO,CAAC,qBAAqB,CAAC,CAQhC;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,qBAAqB,CAAC,CAOhC"}

package/dist/swaps.js

@@ -0,0 +1,39 @@
+import { parseStoreJson, storeFetch } from "./store-api";
+/**
+ * POST /store/swaps
+ */
+export async function medusaSwapCreate(payload, options) {
+    const response = await storeFetch("/swaps", options, {
+        method: "POST",
+        body: JSON.stringify(payload),
+    });
+    const data = await parseStoreJson(response, "Swap create request");
+    return (data.swap ?? data);
+}
+/**
+ * POST /store/guest-orders/:id/swaps
+ */
+export async function medusaSwapCreateGuest(orderId, payload, options) {
+    const response = await storeFetch(`/guest-orders/${encodeURIComponent(orderId)}/swaps`, options, { method: "POST", body: JSON.stringify(payload) });
+    const data = await parseStoreJson(response, "Guest swap create request");
+    return (data.swap ?? data);
+}
+/**
+ * GET /store/swaps
+ */
+export async function medusaSwapList(options, query) {
+    const params = new URLSearchParams();
+    if (query?.order_id) {
+        params.set("order_id", query.order_id);
+    }
+    const path = params.toString() ? `/swaps?${params.toString()}` : "/swaps";
+    const response = await storeFetch(path, options, { method: "GET" });
+    return parseStoreJson(response, "Swap list request");
+}
+/**
+ * GET /store/guest-orders/:id/swaps
+ */
+export async function medusaSwapListGuest(orderId, options) {
+    const response = await storeFetch(`/guest-orders/${encodeURIComponent(orderId)}/swaps`, options, { method: "GET" });
+    return parseStoreJson(response, "Guest swap list request");
+}

package/dist/variants.d.ts

@@ -0,0 +1,17 @@
+import { type MedusaStoreClientOptions } from "./store-api";
+export interface StoreProductVariant {
+    id: string;
+    title?: string;
+    sku?: string;
+    [key: string]: unknown;
+}
+export interface StoreProductVariantResponse {
+    variant: StoreProductVariant;
+}
+/**
+ * GET /store/product-variants/:id
+ */
+export declare function medusaVariantRetrieve(variantId: string, options: MedusaStoreClientOptions, query?: {
+    fields?: string;
+}): Promise<StoreProductVariantResponse>;
+//# sourceMappingURL=variants.d.ts.map

package/dist/variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variants.d.ts","sourceRoot":"","sources":["../variants.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAErG,MAAM,WAAW,mBAAmB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IACxC,OAAO,EAAE,mBAAmB,CAAC;CAChC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACvC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,wBAAwB,EACjC,KAAK,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,OAAO,CAAC,2BAA2B,CAAC,CAOtC"}

package/dist/variants.js

@@ -0,0 +1,8 @@
+import { fieldsQuery, parseStoreJson, storeFetch } from "./store-api";
+/**
+ * GET /store/product-variants/:id
+ */
+export async function medusaVariantRetrieve(variantId, options, query) {
+    const response = await storeFetch(`/product-variants/${encodeURIComponent(variantId)}${fieldsQuery(query?.fields, "*images")}`, options, { method: "GET" });
+    return parseStoreJson(response, "Variant retrieve request");
+}

package/dist/wishlist.d.ts

@@ -0,0 +1,65 @@
+export interface WishlistServiceOptions {
+    storageKey?: string;
+}
+/**
+ * Local-first wishlist (guest / no API).
+ * medusa-product-helper Store routes require a logged-in customer.
+ */
+export declare const wishlistService: {
+    getAll(options?: WishlistServiceOptions): string[];
+    isInWishlist(productId: string, options?: WishlistServiceOptions): boolean;
+    add(productId: string, options?: WishlistServiceOptions): string[];
+    remove(productId: string, options?: WishlistServiceOptions): string[];
+    toggle(productId: string, options?: WishlistServiceOptions): {
+        ids: string[];
+        isWishlisted: boolean;
+    };
+};
+export interface MedusaWishlistClientOptions {
+    backendUrl: string;
+    publishableApiKey: string;
+    /** Customer JWT, or full `Bearer …` value (required for store wishlist routes) */
+    authorization: string;
+    /** Optional extra headers */
+    headers?: Record<string, string>;
+}
+export interface MedusaWishlistItemResponse {
+    id: string;
+    customer_id: string;
+    product_id: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface MedusaAddWishlistResponse {
+    wishlist_item: MedusaWishlistItemResponse;
+}
+/**
+ * POST /store/wishlist — add product (idempotent).
+ */
+export declare function medusaWishlistAdd(productId: string, options: MedusaWishlistClientOptions): Promise<MedusaAddWishlistResponse>;
+/**
+ * DELETE /store/wishlist/:product_id
+ */
+export declare function medusaWishlistRemove(productId: string, options: MedusaWishlistClientOptions): Promise<{
+    success: boolean;
+}>;
+export type MedusaWishlistListEntry = {
+    product_id: string;
+} | {
+    id: string;
+    product_id: string;
+    product?: Record<string, unknown>;
+    created_at?: string;
+};
+export interface MedusaGetWishlistResponse {
+    wishlist: MedusaWishlistListEntry[];
+}
+/**
+ * GET /store/wishlist — optional include_details=true for full product payloads.
+ */
+export declare function medusaWishlistGet(options: MedusaWishlistClientOptions, query?: {
+    includeDetails?: boolean;
+}): Promise<MedusaGetWishlistResponse>;
+/** Product IDs from GET /store/wishlist (both response shapes). */
+export declare function medusaWishlistProductIds(response: MedusaGetWishlistResponse): string[];
+//# sourceMappingURL=wishlist.d.ts.map

package/dist/wishlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wishlist.d.ts","sourceRoot":"","sources":["../wishlist.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAwCD;;;GAGG;AACH,eAAO,MAAM,eAAe;qBACP,sBAAsB,GAAG,MAAM,EAAE;4BAI1B,MAAM,YAAY,sBAAsB,GAAG,OAAO;mBAI3D,MAAM,YAAY,sBAAsB,GAAG,MAAM,EAAE;sBAQhD,MAAM,YAAY,sBAAsB,GAAG,MAAM,EAAE;sBAOnD,MAAM,YAAY,sBAAsB,GAAG;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,OAAO,CAAA;KAAE;CAOxG,CAAC;AAIF,MAAM,WAAW,2BAA2B;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kFAAkF;IAClF,aAAa,EAAE,MAAM,CAAC;IACtB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAiCD,MAAM,WAAW,0BAA0B;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACtC,aAAa,EAAE,0BAA0B,CAAC;CAC7C;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,2BAA2B,GACrC,OAAO,CAAC,yBAAyB,CAAC,CAapC;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,2BAA2B,GACrC,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAa/B;AAED,MAAM,MAAM,uBAAuB,GAC7B;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GACtB;IACI,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAER,MAAM,WAAW,yBAAyB;IACtC,QAAQ,EAAE,uBAAuB,EAAE,CAAC;CACvC;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,2BAA2B,EACpC,KAAK,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GACrC,OAAO,CAAC,yBAAyB,CAAC,CAkBpC;AAED,mEAAmE;AACnE,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,MAAM,EAAE,CAEtF"}

package/dist/wishlist.js

@@ -0,0 +1,149 @@
+const DEFAULT_WISHLIST_STORAGE_KEY = "medusa_pdp_wishlist";
+function getStorageKey(options) {
+    return options?.storageKey || DEFAULT_WISHLIST_STORAGE_KEY;
+}
+function canUseStorage() {
+    return typeof window !== "undefined" && !!window.localStorage;
+}
+function sanitizeIds(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((id) => typeof id === "string" && id.trim() !== "");
+}
+function readWishlistIds(options) {
+    if (!canUseStorage())
+        return [];
+    try {
+        const raw = window.localStorage.getItem(getStorageKey(options));
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        return sanitizeIds(parsed);
+    }
+    catch {
+        return [];
+    }
+}
+function writeWishlistIds(ids, options) {
+    if (!canUseStorage())
+        return;
+    try {
+        window.localStorage.setItem(getStorageKey(options), JSON.stringify(ids));
+    }
+    catch {
+        // Ignore storage errors (quota/private mode)
+    }
+}
+/**
+ * Local-first wishlist (guest / no API).
+ * medusa-product-helper Store routes require a logged-in customer.
+ */
+export const wishlistService = {
+    getAll(options) {
+        return readWishlistIds(options);
+    },
+    isInWishlist(productId, options) {
+        return readWishlistIds(options).includes(productId);
+    },
+    add(productId, options) {
+        const current = readWishlistIds(options);
+        if (current.includes(productId))
+            return current;
+        const next = [productId, ...current];
+        writeWishlistIds(next, options);
+        return next;
+    },
+    remove(productId, options) {
+        const current = readWishlistIds(options);
+        const next = current.filter((id) => id !== productId);
+        writeWishlistIds(next, options);
+        return next;
+    },
+    toggle(productId, options) {
+        const current = readWishlistIds(options);
+        const exists = current.includes(productId);
+        const next = exists ? current.filter((id) => id !== productId) : [productId, ...current];
+        writeWishlistIds(next, options);
+        return { ids: next, isWishlisted: !exists };
+    },
+};
+function normalizeAuth(authorization) {
+    const t = authorization.trim();
+    if (t.toLowerCase().startsWith("bearer "))
+        return t;
+    return `Bearer ${t}`;
+}
+function wishlistStoreBaseUrl(backendUrl) {
+    return `${backendUrl.replace(/\/$/, "")}/store/wishlist`;
+}
+function buildStoreHeaders(options) {
+    const headers = {
+        "Content-Type": "application/json",
+        "x-publishable-api-key": options.publishableApiKey,
+        Authorization: normalizeAuth(options.authorization),
+        ...options.headers,
+    };
+    return headers;
+}
+async function parseErrorMessage(response) {
+    const data = await response.json().catch(() => ({}));
+    const msg = typeof data.message === "string"
+        ? data.message
+        : typeof data.error === "string"
+            ? data.error
+            : `Wishlist request failed (${response.status})`;
+    return msg;
+}
+/**
+ * POST /store/wishlist — add product (idempotent).
+ */
+export async function medusaWishlistAdd(productId, options) {
+    const url = wishlistStoreBaseUrl(options.backendUrl);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: buildStoreHeaders(options),
+        body: JSON.stringify({ product_id: productId }),
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response));
+    }
+    return response.json();
+}
+/**
+ * DELETE /store/wishlist/:product_id
+ */
+export async function medusaWishlistRemove(productId, options) {
+    const base = wishlistStoreBaseUrl(options.backendUrl);
+    const url = `${base}/${encodeURIComponent(productId)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildStoreHeaders(options),
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response));
+    }
+    return response.json();
+}
+/**
+ * GET /store/wishlist — optional include_details=true for full product payloads.
+ */
+export async function medusaWishlistGet(options, query) {
+    const params = new URLSearchParams();
+    if (query?.includeDetails) {
+        params.set("include_details", "true");
+    }
+    const qs = params.toString();
+    const url = `${wishlistStoreBaseUrl(options.backendUrl)}${qs ? `?${qs}` : ""}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildStoreHeaders(options),
+    });
+    if (!response.ok) {
+        throw new Error(await parseErrorMessage(response));
+    }
+    return response.json();
+}
+/** Product IDs from GET /store/wishlist (both response shapes). */
+export function medusaWishlistProductIds(response) {
+    return response.wishlist.map((entry) => entry.product_id).filter(Boolean);
+}

package/middleware.ts

@@ -0,0 +1,54 @@
+/** Edge-safe Medusa store fetches (no Node SDK). */
+
+export interface MedusaMiddlewareClientOptions {
+    backendUrl: string;
+    publishableApiKey: string;
+}
+
+function normalizeBackendUrl(backendUrl: string): string {
+    return backendUrl.replace(/\/$/, "");
+}
+
+export async function medusaListRegions(
+    options: MedusaMiddlewareClientOptions,
+    init?: RequestInit
+): Promise<{ regions: unknown[] }> {
+    const url = `${normalizeBackendUrl(options.backendUrl)}/store/regions`;
+    const response = await fetch(url, {
+        ...init,
+        headers: {
+            "x-publishable-api-key": options.publishableApiKey,
+            ...(init?.headers as Record<string, string> | undefined),
+        },
+    });
+
+    const json = (await response.json()) as { regions?: unknown[]; message?: string };
+    if (!response.ok) {
+        throw new Error(json.message || "Failed to fetch regions");
+    }
+    return { regions: json.regions ?? [] };
+}
+
+export async function medusaMergeCarts(
+    options: MedusaMiddlewareClientOptions & {
+        authorization: string;
+        cartId?: string;
+    },
+    init?: RequestInit
+): Promise<Response> {
+    const url = `${normalizeBackendUrl(options.backendUrl)}/store/carts/merge`;
+    return fetch(url, {
+        method: "POST",
+        ...init,
+        headers: {
+            "Content-Type": "application/json",
+            "x-publishable-api-key": options.publishableApiKey,
+            Authorization: options.authorization.startsWith("Bearer ")
+                ? options.authorization
+                : `Bearer ${options.authorization}`,
+            ...(init?.headers as Record<string, string> | undefined),
+        },
+        body: options.cartId ? JSON.stringify({ cart_id: options.cartId }) : init?.body,
+        cache: init?.cache ?? "no-store",
+    });
+}