@tapcart/mobile-components 0.11.5 → 0.11.6

package/dist/components/ui/money.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../../../components/ui/money.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAGjE,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd;AAED,QAAA,MAAM,aAAa,gGAMjB,CAAA;AAEF,MAAM,WAAW,UACf,SAAQ,SAAS,EACf,YAAY,CAAC,OAAO,aAAa,CAAC;IACpC,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;CAC7B;AAED,iBAAS,KAAK,CAAC,EACb,KAAK,EACL,MAAM,EACN,QAAQ,EACR,aAAqB,EACrB,MAAM,EACN,GAAG,KAAK,EACT,EAAE,UAAU,2CAgDZ;AAED,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,CAAA"}
+{"version":3,"file":"money.d.ts","sourceRoot":"","sources":["../../../components/ui/money.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAGjE,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;CACd;AAED,QAAA,MAAM,aAAa,gGAMjB,CAAA;AAEF,MAAM,WAAW,UACf,SAAQ,SAAS,EACf,YAAY,CAAC,OAAO,aAAa,CAAC;IACpC,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;CAC7B;AAED,iBAAS,KAAK,CAAC,EACb,KAAK,EACL,MAAM,EACN,QAAQ,EACR,aAAqB,EACrB,MAAM,EACN,GAAG,KAAK,EACT,EAAE,UAAU,2CAiFZ;AAED,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,CAAA"}

package/dist/components/ui/money.js

@@ -25,27 +25,59 @@ function Money(_a) {
     var _b, _c;
     var { price, locale, currency, hideZeroCents = false, styles } = _a, props = __rest(_a, ["price", "locale", "currency", "hideZeroCents", "styles"]);
     const searchParams = useSearchParams();
-    const countryFromParams = searchParams === null || searchParams === void 0 ? void 0 : searchParams.get("country");
-    // Only use routeLocale if it's a valid BCP 47 language tag (e.g., "en-US", "fr-FR")
-    const routeLocale = ((_c = (_b = usePathname()) === null || _b === void 0 ? void 0 : _b.split("/")) === null || _c === void 0 ? void 0 : _c.pop()) || "";
-    // Valid locale format: 2-3 letter language code, hyphen, 2 letter country code
-    const localeRegex = /^[a-z]{2,3}-[A-Z]{2}$/;
-    const isValidLocale = routeLocale && localeRegex.test(routeLocale);
-    let language = isValidLocale ? routeLocale : locale;
-    // Fallback to a default locale if none provided or invalid
-    if (!language || typeof language !== "string") {
-        language = "en-US";
-    }
-    // If locale is just a language code (no hyphen), combine with country to create proper BCP 47 locale
-    // e.g., lang=ES + country=MX -> es-MX (not es-ES which would default to euros)
-    if (language && !localeRegex.test(language) && countryFromParams) {
-        language = `${language.toLowerCase()}-${countryFromParams.toUpperCase()}`;
-    }
-    // Fix for when we want to format in USD in english
-    // but language only contains two letter region
-    if (currency === "USD" && !language.includes("-")) {
-        language = `en-${language}`;
-    }
+    const countryFromParams = (searchParams === null || searchParams === void 0 ? void 0 : searchParams.get("country")) || undefined;
+    // Derive a candidate locale from the route or prop, then normalize to a valid BCP 47 tag
+    const routeCandidate = ((_c = (_b = usePathname()) === null || _b === void 0 ? void 0 : _b.split("/")) === null || _c === void 0 ? void 0 : _c.pop()) || "";
+    const normalizeLocale = (baseLocale, countryParam) => {
+        const DEFAULT_LOCALE = "en-US";
+        const raw = (baseLocale || "").replace(/_/g, "-").trim();
+        let languageCode = "";
+        let regionCode = "";
+        if (raw.includes("-")) {
+            const [langPart, regionPart] = raw.split("-");
+            if (langPart)
+                languageCode = langPart.toLowerCase();
+            if (regionPart)
+                regionCode = regionPart.toUpperCase();
+        }
+        else if (raw.length === 2) {
+            if (/^[a-z]{2}$/.test(raw)) {
+                // language only (e.g., "en")
+                languageCode = raw.toLowerCase();
+            }
+            else if (/^[A-Z]{2}$/.test(raw)) {
+                // region only (e.g., "US")
+                regionCode = raw.toUpperCase();
+            }
+            else {
+                languageCode = raw.toLowerCase();
+            }
+        }
+        else if (raw) {
+            // fallback: treat as language subtag
+            languageCode = raw.toLowerCase();
+        }
+        // If a country param is present, prefer it as region
+        if (countryParam) {
+            regionCode = countryParam.toUpperCase();
+        }
+        // Ensure we always have a sensible language
+        if (!languageCode) {
+            languageCode = "en";
+        }
+        const candidate = regionCode
+            ? `${languageCode}-${regionCode}`
+            : languageCode;
+        try {
+            // Validate and canonicalize via NumberFormat
+            const formatter = new Intl.NumberFormat(candidate);
+            return formatter.resolvedOptions().locale;
+        }
+        catch (_a) {
+            return DEFAULT_LOCALE;
+        }
+    };
+    const language = normalizeLocale(routeCandidate || locale, countryFromParams);
     const formatter = React.useMemo(() => new Intl.NumberFormat(language, {
         style: "currency",
         currency: currency,

package/dist/components/ui/money.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=money.test.d.ts.map

package/dist/components/ui/money.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.test.d.ts","sourceRoot":"","sources":["../../../components/ui/money.test.tsx"],"names":[],"mappings":""}

package/dist/components/ui/money.test.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from "@testing-library/react";
+import { Money } from "./money";
+jest.mock("next/navigation", () => ({
+    usePathname: jest.fn(),
+    useSearchParams: jest.fn(),
+}));
+const mockedUsePathname = require("next/navigation").usePathname;
+const mockedUseSearchParams = require("next/navigation")
+    .useSearchParams;
+function makeSearchParams(params) {
+    return {
+        get: (key) => params[key],
+    };
+}
+describe("Money", () => {
+    beforeEach(() => {
+        mockedUsePathname.mockReset();
+        mockedUseSearchParams.mockReset();
+    });
+    it("formats USD with default en-US when no locale provided", () => {
+        mockedUsePathname.mockReturnValue("/");
+        mockedUseSearchParams.mockReturnValue(makeSearchParams({}));
+        render(_jsx(Money, { price: 1234.56, currency: "USD", locale: "" }));
+        expect(screen.getByText(/\$1,234.56/)).toBeTruthy();
+    });
+    it("removes trailing cents when hideZeroCents is true", () => {
+        mockedUsePathname.mockReturnValue("/");
+        mockedUseSearchParams.mockReturnValue(makeSearchParams({}));
+        render(_jsx(Money, { price: 100, currency: "USD", locale: "en-US", hideZeroCents: true }));
+        expect(screen.getByText("$100")).toBeTruthy();
+    });
+    it("uses route locale when valid (e.g., fr-FR)", () => {
+        mockedUsePathname.mockReturnValue("/shop/fr-FR");
+        mockedUseSearchParams.mockReturnValue(makeSearchParams({}));
+        render(_jsx(Money, { price: 1234.56, currency: "EUR", locale: "en-US" }));
+        expect(screen.getByText(/1\s?234,56\s?€/)).toBeTruthy();
+    });
+    it("normalizes underscore and applies country param for region", () => {
+        mockedUsePathname.mockReturnValue("/shop/es_es");
+        mockedUseSearchParams.mockReturnValue(makeSearchParams({ country: "mx" }));
+        render(_jsx(Money, { price: 50, currency: "MXN", locale: "es" }));
+        expect(screen.getByText(/\$\s?50(\.00)?/)).toBeTruthy();
+    });
+    it("avoids malformed tags like en-us-US and falls back safely", () => {
+        mockedUsePathname.mockReturnValue("/en-us-US");
+        mockedUseSearchParams.mockReturnValue(makeSearchParams({}));
+        render(_jsx(Money, { price: 10, currency: "USD", locale: "en-us-US" }));
+        expect(screen.getByText(/\$10(\.00)?/)).toBeTruthy();
+    });
+    it("handles region-only input via country param", () => {
+        mockedUsePathname.mockReturnValue("/US");
+        mockedUseSearchParams.mockReturnValue(makeSearchParams({ country: "US" }));
+        render(_jsx(Money, { price: 20, currency: "USD", locale: "" }));
+        expect(screen.getByText(/\$20(\.00)?/)).toBeTruthy();
+    });
+});

package/dist/lib/isVersion20.util.d.ts

@@ -0,0 +1,2 @@
+export declare const isVersion20: (version: string | null | undefined) => boolean;
+//# sourceMappingURL=isVersion20.util.d.ts.map

package/dist/lib/isVersion20.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isVersion20.util.d.ts","sourceRoot":"","sources":["../../lib/isVersion20.util.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,YAAa,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OAIhE,CAAA"}

package/dist/lib/isVersion20.util.js

@@ -0,0 +1,7 @@
+import { SemVer } from "semver";
+export const isVersion20 = (version) => {
+    if (!version)
+        return false;
+    const currentVersion = new SemVer(version || "0.0.0");
+    return currentVersion.compare("13.20.0") >= 0;
+};

package/dist/lib/utils.wishlist.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.wishlist.test.d.ts.map

package/dist/lib/utils.wishlist.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.wishlist.test.d.ts","sourceRoot":"","sources":["../../lib/utils.wishlist.test.ts"],"names":[],"mappings":""}

package/dist/lib/utils.wishlist.test.js

@@ -0,0 +1,108 @@
+import { findWishlistEntry, getEnabledWishlistIntegration, supportsMultipleWishlists, } from "./utils";
+describe("getEnabledWishlistIntegration", () => {
+    it("returns the first enabled wishlist integration", () => {
+        const integrations = [
+            { name: "tapcart-search", enabled: true },
+            { name: "tapcart-wishlist", enabled: true, multiwishlist: true },
+            { name: "swym", enabled: true },
+        ];
+        const result = getEnabledWishlistIntegration(integrations);
+        expect(result).toEqual({
+            name: "tapcart-wishlist",
+            enabled: true,
+            multiwishlist: true,
+        });
+    });
+    it("returns null when no wishlist integration is enabled", () => {
+        const integrations = [
+            { name: "tapcart-search", enabled: true },
+            { name: "tapcart-wishlist", enabled: false },
+        ];
+        expect(getEnabledWishlistIntegration(integrations)).toBeNull();
+    });
+    it("returns null when integrations is not an array", () => {
+        expect(getEnabledWishlistIntegration(undefined)).toBeNull();
+        expect(getEnabledWishlistIntegration(null)).toBeNull();
+    });
+});
+describe("supportsMultipleWishlists", () => {
+    it("respects explicit multiwishlist flag", () => {
+        expect(supportsMultipleWishlists({
+            name: "tapcart-wishlist",
+            enabled: true,
+            multiwishlist: false,
+        })).toBe(false);
+        expect(supportsMultipleWishlists({
+            name: "tapcart-wishlist",
+            enabled: true,
+            multiwishlist: true,
+        })).toBe(true);
+    });
+    it("defaults to true for known integrations when flag is omitted", () => {
+        expect(supportsMultipleWishlists({
+            name: "tapcart-wishlist-v2",
+            enabled: true,
+        })).toBe(true);
+    });
+    it("returns false for unknown integrations", () => {
+        expect(supportsMultipleWishlists({
+            name: "not-a-wishlist",
+            enabled: true,
+        })).toBe(false);
+    });
+});
+describe("findWishlistEntry", () => {
+    const wishlists = [
+        {
+            id: "wl-1",
+            items: [
+                {
+                    id: "item-1",
+                    productId: "gid://shopify/Product/123",
+                    variantId: "gid://shopify/ProductVariant/456",
+                },
+            ],
+        },
+        {
+            _id: "wl-2",
+            items: [
+                {
+                    id: "item-2",
+                    productId: "789",
+                    variantId: "654",
+                },
+            ],
+        },
+    ];
+    it("finds an entry when product and variant match across gid representations", () => {
+        const match = findWishlistEntry(wishlists, "123", "456");
+        expect(match).toEqual({
+            wishlistId: "wl-1",
+            item: {
+                id: "item-1",
+                productId: "gid://shopify/Product/123",
+                variantId: "gid://shopify/ProductVariant/456",
+            },
+        });
+    });
+    it("falls back to product-only lookup when variant is omitted", () => {
+        const match = findWishlistEntry(wishlists, "789");
+        expect(match).toEqual({
+            wishlistId: "wl-2",
+            item: {
+                id: "item-2",
+                productId: "789",
+                variantId: "654",
+            },
+        });
+    });
+    it("returns null when no matching entry is found", () => {
+        const match = findWishlistEntry(wishlists, "999", "888");
+        expect(match).toBeNull();
+    });
+    it("handles empty or invalid inputs gracefully", () => {
+        expect(findWishlistEntry(undefined, "123")).toBeNull();
+        expect(findWishlistEntry([], "123")).toBeNull();
+        expect(findWishlistEntry(wishlists, undefined)).toBeNull();
+    });
+});

package/dist/styles.css

@@ -778,6 +778,9 @@ video {
 .top-\[50\%\] {
   top: 50%;
 }
+.z-0 {
+  z-index: 0;
+}
 .z-10 {
   z-index: 10;
 }
@@ -886,6 +889,9 @@ video {
 .ml-2 {
   margin-left: 0.5rem;
 }
+.ml-4 {
+  margin-left: 1rem;
+}
 .ml-auto {
   margin-left: auto;
 }

package/dist/tests/addItemToWishlist/addItemToWishlist.wishlistId.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=addItemToWishlist.wishlistId.test.d.ts.map

package/dist/tests/addItemToWishlist/addItemToWishlist.wishlistId.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addItemToWishlist.wishlistId.test.d.ts","sourceRoot":"","sources":["../../../tests/addItemToWishlist/addItemToWishlist.wishlistId.test.ts"],"names":[],"mappings":""}

package/dist/tests/addItemToWishlist/addItemToWishlist.wishlistId.test.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { addItemToWishlist } from "../../lib/utils";
+describe("addItemToWishlist with explicit wishlistId", () => {
+    let mockTapcart;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockTapcart = {
+            action: jest.fn().mockResolvedValue(true),
+            variables: {
+                customer: { id: "customer-123" },
+                wishlists: [{ id: "wishlist-1" }],
+            },
+        };
+    });
+    it("should use the provided wishlistId without opening the drawer", () => __awaiter(void 0, void 0, void 0, function* () {
+        const integrations = [
+            {
+                name: "tapcart-wishlist",
+                enabled: true,
+                multiwishlist: false,
+            },
+        ];
+        const product = {
+            id: "gid://shopify/Product/123",
+            variants: [{ id: "gid://shopify/ProductVariant/456" }],
+        };
+        const result = yield addItemToWishlist({
+            Tapcart: mockTapcart,
+            integrations,
+            product,
+            selectedVariantId: "gid://shopify/ProductVariant/456",
+            wishlistId: "gid://shopify/Wishlist/789",
+        });
+        expect(result).toBe(true);
+        expect(mockTapcart.action).toHaveBeenCalledTimes(1);
+        expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/add", {
+            productId: "123",
+            variantId: "456",
+            wishlistId: "789",
+        });
+    }));
+});

package/dist/tests/removeItemFromWishlist/removeItemFromWishlist.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=removeItemFromWishlist.test.d.ts.map

package/dist/tests/removeItemFromWishlist/removeItemFromWishlist.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeItemFromWishlist.test.d.ts","sourceRoot":"","sources":["../../../tests/removeItemFromWishlist/removeItemFromWishlist.test.ts"],"names":[],"mappings":""}

package/dist/tests/removeItemFromWishlist/removeItemFromWishlist.test.js

@@ -0,0 +1,268 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { removeItemFromWishlist } from "../../lib/utils";
+describe("removeItemFromWishlist", () => {
+    let mockTapcart;
+    let consoleErrorSpy;
+    let consoleLogSpy;
+    beforeEach(() => {
+        // Reset mocks before each test
+        jest.clearAllMocks();
+        // Spy on console methods
+        consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+        consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
+        // Default mock Tapcart instance
+        mockTapcart = {
+            action: jest.fn(),
+            variables: {
+                customer: { id: "customer-123" },
+                wishlists: [
+                    {
+                        id: "wishlist-1",
+                        items: [
+                            {
+                                productId: "gid://shopify/Product/123",
+                                variantId: "gid://shopify/ProductVariant/456",
+                            },
+                        ],
+                    },
+                ],
+            },
+        };
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+    });
+    describe("validation and error handling", () => {
+        it("should return false when Tapcart instance is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield removeItemFromWishlist({
+                Tapcart: null,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Tapcart instance is missing");
+        }));
+        it("should handle errors gracefully and return false", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to throw an error
+            mockTapcart.action = jest.fn().mockImplementation(() => {
+                throw new Error("Test error");
+            });
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to remove from wishlist", expect.any(Error));
+        }));
+    });
+    describe("variant ID handling", () => {
+        it("should return false when variant ID is missing from both wishlist entry and selectedVariantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with no variant ID in wishlist entry
+            mockTapcart.variables.wishlists[0].items[0].variantId = null;
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: null,
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing variant id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should use variant ID from wishlist entry when available", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: null,
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should use selectedVariantId when wishlist entry has no variant ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with no variant ID in wishlist entry
+            mockTapcart.variables.wishlists[0].items[0].variantId = null;
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "789",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should prioritize wishlist entry variant ID over selectedVariantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+    });
+    describe("wishlist ID handling", () => {
+        it("should return false when wishlist ID is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with no wishlist ID
+            mockTapcart.variables.wishlists = [];
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing wishlist id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should use wishlist ID from wishlist entry when available", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "wishlist-1", // From wishlist entry
+            });
+        }));
+    });
+    describe("GID handling", () => {
+        it("should extract IDs from GID format", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with GID format
+            mockTapcart.variables.wishlists[0].items[0].productId = "gid://shopify/Product/123?param=value";
+            mockTapcart.variables.wishlists[0].items[0].variantId = "gid://shopify/ProductVariant/456?param=value";
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123?param=value",
+                selectedVariantId: "gid://shopify/ProductVariant/789?param=value",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123?param=value",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should handle plain IDs without GID format", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with plain IDs
+            mockTapcart.variables.wishlists[0].items[0].productId = "123";
+            mockTapcart.variables.wishlists[0].items[0].variantId = "456";
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "123",
+                selectedVariantId: "789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "123",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should use the provided wishlistId when supplied", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists = [];
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+                wishlistId: "gid://shopify/Wishlist/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "789",
+            });
+        }));
+    });
+    describe("edge cases", () => {
+        it("should handle undefined wishlists array", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists = undefined;
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing wishlist id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should handle empty wishlists array", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists = [];
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing wishlist id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should handle wishlist entry with undefined variantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists[0].items[0].variantId = undefined;
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "789",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should handle wishlist entry with null variantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists[0].items[0].variantId = null;
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "789",
+                wishlistId: "wishlist-1",
+            });
+        }));
+    });
+});

package/dist/tests/removeItemFromWishlists/removeItemFromWishlist.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=removeItemFromWishlist.test.d.ts.map

package/dist/tests/removeItemFromWishlists/removeItemFromWishlist.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeItemFromWishlist.test.d.ts","sourceRoot":"","sources":["../../../tests/removeItemFromWishlists/removeItemFromWishlist.test.ts"],"names":[],"mappings":""}

package/dist/tests/removeItemFromWishlists/removeItemFromWishlist.test.js

@@ -0,0 +1,268 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { removeItemFromWishlist } from "../../lib/utils";
+describe("removeItemFromWishlist", () => {
+    let mockTapcart;
+    let consoleErrorSpy;
+    let consoleLogSpy;
+    beforeEach(() => {
+        // Reset mocks before each test
+        jest.clearAllMocks();
+        // Spy on console methods
+        consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+        consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
+        // Default mock Tapcart instance
+        mockTapcart = {
+            action: jest.fn(),
+            variables: {
+                customer: { id: "customer-123" },
+                wishlists: [
+                    {
+                        id: "wishlist-1",
+                        items: [
+                            {
+                                productId: "gid://shopify/Product/123",
+                                variantId: "gid://shopify/ProductVariant/456",
+                            },
+                        ],
+                    },
+                ],
+            },
+        };
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        consoleLogSpy.mockRestore();
+    });
+    describe("validation and error handling", () => {
+        it("should return false when Tapcart instance is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield removeItemFromWishlist({
+                Tapcart: null,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Tapcart instance is missing");
+        }));
+        it("should handle errors gracefully and return false", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to throw an error
+            mockTapcart.action = jest.fn().mockImplementation(() => {
+                throw new Error("Test error");
+            });
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to remove from wishlist", expect.any(Error));
+        }));
+    });
+    describe("variant ID handling", () => {
+        it("should return false when variant ID is missing from both wishlist entry and selectedVariantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with no variant ID in wishlist entry
+            mockTapcart.variables.wishlists[0].items[0].variantId = null;
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: null,
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing variant id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should use variant ID from wishlist entry when available", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: null,
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should use selectedVariantId when wishlist entry has no variant ID", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with no variant ID in wishlist entry
+            mockTapcart.variables.wishlists[0].items[0].variantId = null;
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "789",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should prioritize wishlist entry variant ID over selectedVariantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+    });
+    describe("wishlist ID handling", () => {
+        it("should return false when wishlist ID is missing", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with no wishlist ID
+            mockTapcart.variables.wishlists = [];
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing wishlist id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should use wishlist ID from wishlist entry when available", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "wishlist-1", // From wishlist entry
+            });
+        }));
+    });
+    describe("GID handling", () => {
+        it("should extract IDs from GID format", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with GID format
+            mockTapcart.variables.wishlists[0].items[0].productId = "gid://shopify/Product/123?param=value";
+            mockTapcart.variables.wishlists[0].items[0].variantId = "gid://shopify/ProductVariant/456?param=value";
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123?param=value",
+                selectedVariantId: "gid://shopify/ProductVariant/789?param=value",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123?param=value",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should handle plain IDs without GID format", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock Tapcart with plain IDs
+            mockTapcart.variables.wishlists[0].items[0].productId = "123";
+            mockTapcart.variables.wishlists[0].items[0].variantId = "456";
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "123",
+                selectedVariantId: "789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "123",
+                variantId: "456",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should use the provided wishlistId when supplied", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists = [];
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+                wishlistId: "gid://shopify/Wishlist/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "456",
+                wishlistId: "789",
+            });
+        }));
+    });
+    describe("edge cases", () => {
+        it("should handle undefined wishlists array", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists = undefined;
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing wishlist id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should handle empty wishlists array", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists = [];
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/456",
+            });
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith("Missing wishlist id for wishlist removal");
+            expect(mockTapcart.action).not.toHaveBeenCalled();
+        }));
+        it("should handle wishlist entry with undefined variantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists[0].items[0].variantId = undefined;
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "789",
+                wishlistId: "wishlist-1",
+            });
+        }));
+        it("should handle wishlist entry with null variantId", () => __awaiter(void 0, void 0, void 0, function* () {
+            mockTapcart.variables.wishlists[0].items[0].variantId = null;
+            // Mock Tapcart.action to return a success result
+            mockTapcart.action = jest.fn().mockResolvedValue(true);
+            const result = yield removeItemFromWishlist({
+                Tapcart: mockTapcart,
+                productId: "gid://shopify/Product/123",
+                selectedVariantId: "gid://shopify/ProductVariant/789",
+            });
+            expect(result).toBe(true);
+            expect(mockTapcart.action).toHaveBeenCalledWith("wishlist/item/remove", {
+                productId: "gid://shopify/Product/123",
+                variantId: "789",
+                wishlistId: "wishlist-1",
+            });
+        }));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapcart/mobile-components",
-  "version": "0.11.5",
+  "version": "0.11.6",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "style": "dist/styles.css",