medusa-services 1.1.0

package/dist/payment.js

@@ -0,0 +1,68 @@
+import { parseStoreErrorMessage, parseStoreJson, storeFetch, } from "./store-api";
+/**
+ * GET /store/payment-providers?region_id=
+ */
+export async function medusaPaymentProvidersList(regionId, options) {
+    const params = new URLSearchParams();
+    params.set("region_id", regionId);
+    const response = await storeFetch(`/payment-providers?${params.toString()}`, options, {
+        method: "GET",
+    });
+    return parseStoreJson(response, "Payment providers request");
+}
+/**
+ * POST /store/payment-collections then POST /store/payment-collections/:id/payment-sessions
+ * (Medusa v2 — cart-scoped /payment-sessions is not available)
+ */
+export async function medusaPaymentSessionInitiate(cartId, body, options) {
+    const collectionResponse = await storeFetch("/payment-collections", options, {
+        method: "POST",
+        body: JSON.stringify({ cart_id: cartId }),
+    });
+    const collectionData = await parseStoreJson(collectionResponse, "Payment collection create request");
+    const paymentCollectionId = collectionData.payment_collection?.id;
+    if (!paymentCollectionId) {
+        throw new Error("Could not create payment collection for cart");
+    }
+    const response = await storeFetch(`/payment-collections/${encodeURIComponent(paymentCollectionId)}/payment-sessions`, options, {
+        method: "POST",
+        body: JSON.stringify({
+            provider_id: body.provider_id,
+            data: body.data,
+        }),
+    });
+    return parseStoreJson(response, "Payment session initiate request");
+}
+/**
+ * GET /store/payment-details
+ */
+export async function medusaPaymentDetailsList(options) {
+    const response = await storeFetch("/payment-details", options, { method: "GET" });
+    return parseStoreJson(response, "Payment details list request");
+}
+/**
+ * POST /store/payment-details
+ */
+export async function medusaPaymentDetailCreate(type, detail_json, options) {
+    const response = await storeFetch("/payment-details", options, {
+        method: "POST",
+        body: JSON.stringify({ type, detail_json }),
+    });
+    return parseStoreJson(response, "Payment detail create request");
+}
+/**
+ * POST /store/payment-details/:id/make-default
+ */
+export async function medusaPaymentDetailMakeDefault(id, options) {
+    const response = await storeFetch(`/payment-details/${encodeURIComponent(id)}/make-default`, options, { method: "POST", body: JSON.stringify({}) });
+    return parseStoreJson(response, "Payment detail make-default request");
+}
+/**
+ * DELETE /store/payment-details/:id
+ */
+export async function medusaPaymentDetailDelete(id, options) {
+    const response = await storeFetch(`/payment-details/${encodeURIComponent(id)}`, options, { method: "DELETE" });
+    if (!response.ok) {
+        throw new Error(await parseStoreErrorMessage(response, "Payment detail delete request"));
+    }
+}

package/dist/product-detail.d.ts

@@ -0,0 +1,30 @@
+import { HttpTypes } from "@medusajs/types";
+/**
+ * Service to handle Product Detail API calls
+ */
+/**
+ * Fetch a single product by its ID or Handle
+ *
+ * @param sdk - The Medusa JS Client SDK instance
+ * @param identifier - The Product ID or Handle
+ * @param isHandle - Set to true if querying by handle instead of ID
+ * @param regionId - (Optional) Region ID to fetch regional pricing
+ * @param headers - (Optional) Custom headers
+ * @returns The fetched product data or null if not found
+ */
+export declare function getProduct({ sdk, identifier, isHandle, regionId, headers, next }: {
+    sdk: any;
+    identifier: string;
+    isHandle?: boolean;
+    regionId?: string;
+    headers?: Record<string, string>;
+    next?: any;
+}): Promise<HttpTypes.StoreProduct | null>;
+/**
+ * Format the raw Medusa product response to match the `ProductData` interface expected by `useProduct.ts`
+ *
+ * @param product - Raw StoreProduct from Medusa
+ * @returns Formatted product data compatible with useProduct hook
+ */
+export declare function formatProductData(product: HttpTypes.StoreProduct): any;
+//# sourceMappingURL=product-detail.d.ts.map

package/dist/product-detail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"product-detail.d.ts","sourceRoot":"","sources":["../product-detail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;GAEG;AAEH;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAAC,EAC7B,GAAG,EACH,UAAU,EACV,QAAgB,EAChB,QAAQ,EACR,OAAY,EACZ,IAAS,EACZ,EAAE;IACC,GAAG,EAAE,GAAG,CAAA;IACR,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,IAAI,CAAC,EAAE,GAAG,CAAA;CACb,GAAG,OAAO,CAAC,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,CA4BzC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,YAAY,GAAG,GAAG,CAmDtE"}

package/dist/product-detail.js

@@ -0,0 +1,94 @@
+/**
+ * Service to handle Product Detail API calls
+ */
+/**
+ * Fetch a single product by its ID or Handle
+ *
+ * @param sdk - The Medusa JS Client SDK instance
+ * @param identifier - The Product ID or Handle
+ * @param isHandle - Set to true if querying by handle instead of ID
+ * @param regionId - (Optional) Region ID to fetch regional pricing
+ * @param headers - (Optional) Custom headers
+ * @returns The fetched product data or null if not found
+ */
+export async function getProduct({ sdk, identifier, isHandle = false, regionId, headers = {}, next = {} }) {
+    try {
+        const queryParams = {
+            fields: "*variants,*variants.prices,*options,*variants.options,*tags,*categories,*images",
+        };
+        if (regionId) {
+            queryParams.region_id = regionId;
+        }
+        let response;
+        if (isHandle) {
+            // Fetch product by handle via product list endpoint
+            queryParams.handle = identifier;
+            const result = await sdk.store.product.list(queryParams, { next, headers });
+            response = result.products?.[0] || null;
+        }
+        else {
+            // Fetch product by ID
+            const result = await sdk.store.product.retrieve(identifier, queryParams, { next, headers });
+            response = result.product || null;
+        }
+        return response;
+    }
+    catch (error) {
+        console.error(`❌ Failed to fetch product (Identifier: ${identifier}):`, error);
+        return null;
+    }
+}
+/**
+ * Format the raw Medusa product response to match the `ProductData` interface expected by `useProduct.ts`
+ *
+ * @param product - Raw StoreProduct from Medusa
+ * @returns Formatted product data compatible with useProduct hook
+ */
+export function formatProductData(product) {
+    if (!product)
+        return null;
+    // Map Options
+    const options = product.options?.map(opt => ({
+        name: opt.title,
+        values: opt.values?.map(v => v.value) || []
+    })) || [];
+    // Map Variants
+    const variants = product.variants?.map((variant) => {
+        // Build an option dictionary like { Size: 'M', Color: 'Red' }
+        const variantOptions = {};
+        variant.options?.forEach((vo) => {
+            const parentOption = product.options?.find(o => o.id === vo.option_id);
+            if (parentOption && parentOption.title) {
+                variantOptions[parentOption.title] = vo.value;
+            }
+        });
+        // Price Calculation (Take the first calculated price for simplicity, assuming region is already applied)
+        const calculatedPriceInfo = variant.calculated_price || variant.prices?.[0] || {};
+        const price = calculatedPriceInfo.calculated_amount || calculatedPriceInfo.amount || 0;
+        const originalPrice = calculatedPriceInfo.original_amount || price;
+        return {
+            id: variant.id,
+            title: variant.title,
+            options: variantOptions,
+            price: price,
+            originalPrice: originalPrice,
+            inventoryQuantity: variant.inventory_quantity || 0,
+            allowBackorder: variant.allow_backorder || false,
+            image: variant.thumbnail || null
+        };
+    }) || [];
+    return {
+        id: product.id,
+        title: product.title,
+        handle: product.handle || undefined,
+        description: product.description || '',
+        collectionId: product.collection_id || undefined,
+        brand: product.collection?.title || undefined,
+        tags: product.tags?.map(t => t.value) || [],
+        tagIds: product.tags?.map(t => t.id).filter(Boolean) || [],
+        categories: product.categories?.map(c => c.name) || [],
+        options,
+        variants,
+        mediaUrls: product.images?.map(img => img.url) || (product.thumbnail ? [product.thumbnail] : [])
+    };
+}

package/dist/product-listing.d.ts

@@ -0,0 +1,81 @@
+import type { HttpTypes } from "@medusajs/types";
+export type SortOptions = "price_asc" | "price_desc" | "created_at" | "created_at_desc" | "created_at_asc" | "bestsellers";
+/**
+ * Client-side product sort helper (used when backend does not sort natively).
+ */
+export declare function sortProducts(products: HttpTypes.StoreProduct[], sortBy: SortOptions): HttpTypes.StoreProduct[];
+/**
+ * Search products by query
+ */
+export declare const searchProducts: ({ sdk, query, region, page, limit, headers, next }: {
+    sdk: any;
+    query: string;
+    region: HttpTypes.StoreRegion;
+    page?: number;
+    limit?: number;
+    headers?: Record<string, string>;
+    next?: any;
+}) => Promise<{
+    response: {
+        products: HttpTypes.StoreProduct[];
+        count: number;
+    };
+    nextPage: number | null;
+}>;
+/**
+ * List products with pagination and filters
+ */
+export declare const listProducts: ({ sdk, region, pageParam, queryParams, headers, next }: {
+    sdk: any;
+    region: HttpTypes.StoreRegion;
+    pageParam?: number;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductListParams;
+    headers?: Record<string, string>;
+    next?: any;
+}) => Promise<{
+    response: {
+        products: HttpTypes.StoreProduct[];
+        count: number;
+    };
+    nextPage: number | null;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductListParams;
+}>;
+/**
+ * List products with sorting applied on the client-side (up to 100 products)
+ */
+export declare const listProductsWithSort: ({ sdk, region, page, limit, queryParams, sortBy, headers, next }: {
+    sdk: any;
+    region: HttpTypes.StoreRegion;
+    page?: number;
+    limit?: number;
+    queryParams?: HttpTypes.FindParams & HttpTypes.StoreProductListParams;
+    sortBy?: SortOptions;
+    headers?: Record<string, string>;
+    next?: any;
+}) => Promise<{
+    response: {
+        products: HttpTypes.StoreProduct[];
+        count: number;
+    };
+    nextPage: number | null;
+}>;
+/**
+ * Fetch the total order count for a product
+ */
+export declare const getProductOrderCount: ({ sdk, productId, headers, next }: {
+    sdk: any;
+    productId: string;
+    headers?: Record<string, string>;
+    next?: any;
+}) => Promise<number>;
+/**
+ * Fetch product with updated inventory/stock data
+ */
+export declare const getProductWithInventory: ({ sdk, productId, region, headers, next }: {
+    sdk: any;
+    productId: string;
+    region: HttpTypes.StoreRegion;
+    headers?: Record<string, string>;
+    next?: any;
+}) => Promise<HttpTypes.StoreProduct | null>;
+//# sourceMappingURL=product-listing.d.ts.map

package/dist/product-listing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"product-listing.d.ts","sourceRoot":"","sources":["../product-listing.ts"],"names":[],"mappings":"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"}

package/dist/product-listing.js

@@ -0,0 +1,189 @@
+/**
+ * Client-side product sort helper (used when backend does not sort natively).
+ */
+export function sortProducts(products, sortBy) {
+    const sortedProducts = [...products];
+    if (["price_asc", "price_desc"].includes(sortBy)) {
+        sortedProducts.forEach((product) => {
+            if (product.variants && product.variants.length > 0) {
+                product._minPrice = Math.min(...product.variants.map((variant) => variant?.calculated_price?.calculated_amount || 0));
+            }
+            else {
+                product._minPrice = Infinity;
+            }
+        });
+        sortedProducts.sort((a, b) => {
+            const diff = a._minPrice - b._minPrice;
+            return sortBy === "price_asc" ? diff : -diff;
+        });
+    }
+    if (sortBy === "created_at" || sortBy === "created_at_desc") {
+        sortedProducts.sort((a, b) => {
+            return new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
+        });
+    }
+    if (sortBy === "created_at_asc") {
+        sortedProducts.sort((a, b) => {
+            return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
+        });
+    }
+    return sortedProducts;
+}
+/**
+ * Search products by query
+ */
+export const searchProducts = async ({ sdk, query, region, page = 1, limit = 12, headers = {}, next = {} }) => {
+    const offset = (page - 1) * limit;
+    const response = await sdk.client.fetch(`/store/products`, {
+        method: "GET",
+        query: {
+            q: query,
+            limit,
+            offset,
+            region_id: region.id,
+            fields: "*variants.calculated_price,*variants.prices,+variants.inventory_quantity,*variants.images,*images,*categories,*categories.parent_category,+metadata,+tags,*thumbnail,"
+        },
+        headers,
+        next,
+        cache: "no-store",
+    });
+    const totalPages = Math.ceil(response.count / limit);
+    const nextPage = page < totalPages ? page + 1 : null;
+    return {
+        response: {
+            products: response.products,
+            count: response.count,
+        },
+        nextPage,
+    };
+};
+/**
+ * List products with pagination and filters
+ */
+export const listProducts = async ({ sdk, region, pageParam = 1, queryParams, headers = {}, next = {} }) => {
+    const limit = queryParams?.limit || 12;
+    const _pageParam = Math.max(pageParam, 1);
+    const offset = _pageParam === 1 ? 0 : (_pageParam - 1) * limit;
+    return sdk.client
+        .fetch(`/store/products`, {
+        method: "GET",
+        query: {
+            limit,
+            offset,
+            region_id: region.id,
+            fields: "*variants.calculated_price,*variants.prices,+variants.inventory_quantity,*variants.images,*images,*categories,*categories.parent_category,+metadata,+tags,*thumbnail,",
+            ...queryParams,
+        },
+        headers,
+        next,
+        cache: "force-cache",
+    })
+        .then(({ products, count }) => {
+        const nextPage = count > offset + limit ? pageParam + 1 : null;
+        return {
+            response: {
+                products,
+                count,
+            },
+            nextPage: nextPage,
+            queryParams,
+        };
+    });
+};
+/**
+ * List products with sorting applied on the client-side (up to 100 products)
+ */
+export const listProductsWithSort = async ({ sdk, region, page = 1, limit = 12, queryParams, sortBy = "created_at", headers = {}, next = {} }) => {
+    const BATCH_SIZE = 100;
+    let allProducts = [];
+    let offset = 0;
+    let totalCount = 0;
+    // Fetch all products in batches
+    do {
+        const { products, count } = await sdk.client.fetch(`/store/products`, {
+            method: "GET",
+            query: {
+                limit: BATCH_SIZE,
+                offset,
+                region_id: region.id,
+                fields: "*variants.calculated_price,*variants.prices,+variants.inventory_quantity,*variants.images,*images,*categories,*categories.parent_category,+metadata,+tags,*thumbnail,",
+                ...queryParams,
+            },
+            headers,
+            next,
+            cache: "force-cache",
+        });
+        allProducts = [...allProducts, ...products];
+        totalCount = count;
+        offset += BATCH_SIZE;
+        // Safety check to avoid infinite loops if totalCount is somehow inconsistent
+        if (products.length === 0)
+            break;
+    } while (allProducts.length < totalCount);
+    const sortedProducts = sortProducts(allProducts, sortBy);
+    const paginatedProducts = sortedProducts.slice((page - 1) * limit, page * limit);
+    const nextPage = sortedProducts.length > page * limit ? page + 1 : null;
+    return {
+        response: {
+            products: paginatedProducts,
+            count: sortedProducts.length,
+        },
+        nextPage,
+    };
+};
+/**
+ * Fetch the total order count for a product
+ */
+export const getProductOrderCount = async ({ sdk, productId, headers = {}, next = {} }) => {
+    try {
+        const response = await sdk.client.fetch(`/store/orders`, {
+            method: "GET",
+            query: {
+                limit: 1000,
+                fields: "*items,*items.variant,*items.product",
+            },
+            headers,
+            next,
+            cache: "force-cache",
+        });
+        if (!response.orders) {
+            return 0;
+        }
+        let orderCount = 0;
+        for (const order of response.orders) {
+            if (order.items?.some((item) => item.product?.id === productId || item.variant?.product_id === productId)) {
+                orderCount++;
+            }
+        }
+        return orderCount;
+    }
+    catch (error) {
+        console.error("Failed to fetch product order count:", error);
+        return 0;
+    }
+};
+/**
+ * Fetch product with updated inventory/stock data
+ */
+export const getProductWithInventory = async ({ sdk, productId, region, headers = {}, next = {} }) => {
+    try {
+        const response = await sdk.client.fetch(`/store/products/${productId}`, {
+            method: "GET",
+            query: {
+                region_id: region.id,
+                fields: "*variants.calculated_price,*variants.prices,+variants.inventory_quantity,*variants.manage_inventory,*variants.allow_backorder,*variants.images,*images,*categories,*categories.parent_category,+metadata,+tags,*thumbnail,",
+            },
+            headers,
+            next,
+            cache: "no-store",
+        });
+        if (!response || !response.product) {
+            return null;
+        }
+        return response.product;
+    }
+    catch (error) {
+        console.error("❌ Error fetching product inventory:", error);
+        return null;
+    }
+};

package/dist/products.d.ts

@@ -0,0 +1,41 @@
+import { type MedusaStoreClientOptions } from "./store-api";
+export interface StoreProduct {
+    id: string;
+    title?: string;
+    handle?: string;
+    created_at?: string;
+    variants?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+export interface StoreProductListResponse {
+    products: StoreProduct[];
+    count: number;
+}
+export declare const MEDUSA_PRODUCT_LIST_FIELDS = "*variants.calculated_price,+variants.inventory_quantity,*variants.images,+variants.metadata,+variants.options,+metadata,+tags,+average_rating,+total_rating_count,+total_rating_sum,";
+export declare const MEDUSA_PRODUCT_HANDLE_FIELDS = "*variants.calculated_price,+variants.inventory_quantity,+variants.manage_inventory,+variants.allow_backorder,*variants.options,*options,*options.values,*images,*thumbnail,+metadata";
+export interface MedusaProductListParams {
+    pageParam?: number;
+    limit?: number;
+    regionId?: string;
+    queryParams?: Record<string, unknown>;
+}
+/**
+ * GET /store/products or /store/product-helper/products
+ */
+export declare function medusaProductList(options: MedusaStoreClientOptions, params: MedusaProductListParams): Promise<{
+    products: StoreProduct[];
+    count: number;
+    nextPage: number | null;
+}>;
+/**
+ * GET /store/products?handle=
+ */
+export declare function medusaProductByHandle(handle: string, options: MedusaStoreClientOptions, query?: {
+    fields?: string;
+    region_id?: string;
+}): Promise<StoreProduct | null>;
+/**
+ * GET /store/product-helper/filters
+ */
+export declare function medusaProductHelperFilters(options: MedusaStoreClientOptions): Promise<Record<string, unknown>>;
+//# sourceMappingURL=products.d.ts.map

package/dist/products.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"products.d.ts","sourceRoot":"","sources":["../products.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAExF,MAAM,WAAW,YAAY;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,wBAAwB;IACrC,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,0BAA0B,yLACmJ,CAAC;AAE3L,eAAO,MAAM,4BAA4B,yLACiJ,CAAC;AA0G3L,MAAM,WAAW,uBAAuB;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,uBAAuB,GAChC,OAAO,CAAC;IAAE,QAAQ,EAAE,YAAY,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAiC/E;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,EACjC,KAAK,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAChD,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAS9B;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAGlC"}

package/dist/products.js

@@ -0,0 +1,141 @@
+import { parseStoreJson, storeFetch } from "./store-api";
+export const MEDUSA_PRODUCT_LIST_FIELDS = "*variants.calculated_price,+variants.inventory_quantity,*variants.images,+variants.metadata,+variants.options,+metadata,+tags,+average_rating,+total_rating_count,+total_rating_sum,";
+export const MEDUSA_PRODUCT_HANDLE_FIELDS = "*variants.calculated_price,+variants.inventory_quantity,+variants.manage_inventory,+variants.allow_backorder,*variants.options,*options,*options.values,*images,*thumbnail,+metadata";
+const ADVANCED_FILTER_KEYS = [
+    "metadata",
+    "min_price",
+    "max_price",
+    "q",
+    "collection_id",
+    "category_id",
+    "tags",
+    "option_value",
+    "gender",
+    "color",
+    "material",
+    "style",
+    "brand",
+    "type",
+    "product_type",
+    "order",
+];
+function hasAdvancedFilters(queryParams) {
+    if (!queryParams)
+        return false;
+    return Object.keys(queryParams).some((key) => ADVANCED_FILTER_KEYS.includes(key) &&
+        queryParams[key] !== undefined &&
+        queryParams[key] !== null);
+}
+function buildHelperQueryParams(regionId, limit, offset, queryParams) {
+    const params = new URLSearchParams();
+    params.append("limit", limit.toString());
+    params.append("offset", offset.toString());
+    if (regionId)
+        params.append("region_id", regionId);
+    params.append("fields", "*");
+    for (const [key, value] of Object.entries(queryParams ?? {})) {
+        if (["metadata", "min_price", "max_price", "limit", "offset", "region_id", "fields"].includes(key)) {
+            continue;
+        }
+        const values = Array.isArray(value) ? value : [value];
+        const lowerKey = key.toLowerCase();
+        if (lowerKey === "color") {
+            values.forEach((v) => params.append("option_value[]", String(v)));
+        }
+        else if (["material", "gender", "product_type", "type", "style", "brand"].includes(lowerKey)) {
+            const metaKey = lowerKey === "type" ? "product_type" : lowerKey;
+            values.forEach((v) => params.append(`metadata[${metaKey}]`, String(v)));
+        }
+        else if (Array.isArray(value)) {
+            value.forEach((v) => params.append(`${key}[]`, String(v)));
+        }
+        else if (value !== undefined && value !== null) {
+            params.append(key, String(value));
+        }
+    }
+    if (queryParams?.min_price)
+        params.append("price_min", String(queryParams.min_price));
+    if (queryParams?.max_price)
+        params.append("price_max", String(queryParams.max_price));
+    if (queryParams?.metadata && typeof queryParams.metadata === "object") {
+        for (const [key, value] of Object.entries(queryParams.metadata)) {
+            const values = Array.isArray(value) ? value : [value];
+            values.forEach((v) => {
+                if (key.toLowerCase() === "color") {
+                    params.append("option_value[]", String(v));
+                }
+                else {
+                    params.append(`metadata[${key}]`, String(v));
+                }
+            });
+        }
+    }
+    return params;
+}
+function buildStandardQuery(regionId, limit, offset, queryParams) {
+    const finalQuery = {
+        limit,
+        offset,
+        fields: MEDUSA_PRODUCT_LIST_FIELDS,
+    };
+    if (regionId)
+        finalQuery.region_id = regionId;
+    const safeKeys = ["order", "id", "handle", "status", "created_at", "updated_at", "type_id"];
+    for (const key of safeKeys) {
+        if (queryParams?.[key] !== undefined && queryParams[key] !== null) {
+            finalQuery[key] = queryParams[key];
+        }
+    }
+    return finalQuery;
+}
+/**
+ * GET /store/products or /store/product-helper/products
+ */
+export async function medusaProductList(options, params) {
+    const limit = params.limit ?? params.queryParams?.limit ?? 12;
+    const pageParam = Math.max(params.pageParam ?? 1, 1);
+    const offset = pageParam === 1 ? 0 : (pageParam - 1) * limit;
+    const useHelper = hasAdvancedFilters(params.queryParams);
+    let response;
+    if (useHelper) {
+        const query = buildHelperQueryParams(params.regionId, limit, offset, params.queryParams);
+        response = await storeFetch(`/product-helper/products?${query.toString()}`, options, {
+            method: "GET",
+        });
+    }
+    else {
+        const query = buildStandardQuery(params.regionId, limit, offset, params.queryParams);
+        const search = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            search.set(key, String(value));
+        }
+        response = await storeFetch(`/products?${search.toString()}`, options, { method: "GET" });
+    }
+    const { products, count } = await parseStoreJson(response, "Product list request");
+    const nextPage = count > offset + limit ? pageParam + 1 : null;
+    return {
+        products: products ?? [],
+        count: count ?? 0,
+        nextPage,
+    };
+}
+/**
+ * GET /store/products?handle=
+ */
+export async function medusaProductByHandle(handle, options, query) {
+    const params = new URLSearchParams();
+    params.set("handle", handle);
+    params.set("fields", query?.fields ?? MEDUSA_PRODUCT_HANDLE_FIELDS);
+    if (query?.region_id)
+        params.set("region_id", query.region_id);
+    const response = await storeFetch(`/products?${params.toString()}`, options, { method: "GET" });
+    const data = await parseStoreJson(response, "Product by handle request");
+    return data.products?.[0] ?? null;
+}
+/**
+ * GET /store/product-helper/filters
+ */
+export async function medusaProductHelperFilters(options) {
+    const response = await storeFetch("/product-helper/filters", options, { method: "GET" });
+    return parseStoreJson(response, "Product filters request");
+}

package/dist/recently-viewed.d.ts

@@ -0,0 +1,14 @@
+export interface RecentlyViewedServiceOptions {
+    storageKey?: string;
+    maxItems?: number;
+}
+/**
+ * Local-first recently viewed service.
+ * Later, swap internals with API calls without changing callers.
+ */
+export declare const recentlyViewedService: {
+    getAll(options?: RecentlyViewedServiceOptions): string[];
+    track(productId: string, options?: RecentlyViewedServiceOptions): string[];
+    clear(options?: RecentlyViewedServiceOptions): void;
+};
+//# sourceMappingURL=recently-viewed.d.ts.map

package/dist/recently-viewed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recently-viewed.d.ts","sourceRoot":"","sources":["../recently-viewed.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,4BAA4B;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AA8CD;;;GAGG;AACH,eAAO,MAAM,qBAAqB;qBACb,4BAA4B,GAAG,MAAM,EAAE;qBAIvC,MAAM,YAAY,4BAA4B,GAAG,MAAM,EAAE;oBAO1D,4BAA4B,GAAG,IAAI;CAGtD,CAAC"}